comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
'Invalid address' | //SPDX-License-Identifier: MIT
pragma solidity =0.8.18;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
/**
* @title Minting
* @author gotbit
* @notice Contract for staking tokens in order to earn rewards. Any user can make multiple stakes. Reward earn period is practically unlimited.
*/
contract Minting is Ownable, Pausable {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.UintSet;
// TYPES
struct Stake {
address owner;
uint256 amount;
uint256 rewardToUser;
uint32 apy;
uint32 unstakedAtBlockTimestamp;
uint32 stakingPeriod;
uint32 timestamp;
}
// STATE VARIABLES
uint256 public constant ACCURACY = 1e18;
uint256 public constant MIN_STAKING_PERIOD = 1 days; // 1 day
uint256 public constant MAX_STAKING_PERIOD = YEAR * 5; // 5 year
uint256 public constant RECEIVE_PERIOD = 14 days; // 14 days
uint256 public constant ONE_HUNDRED = 100; // 100%
uint256 public constant APY_4 = 4; // 4%
uint256 public constant APY_7 = 7; // 7%
uint256 public constant APY_15 = 15; // 15%
uint256 public constant APY_34 = 34; // 34%
uint256 public constant APY_53 = 53; // 53%
uint256 public constant APY_67 = 67; // 67%
uint256 public constant APY_75 = 75; // 75%
uint256 public constant APY_84 = 84; // 84%
uint256 public constant YEAR = 360 days; // 365 days = 1 year
// uint256 ~ 10*77 => 10**77 ~ amount * 100 * 10**10 = amount * 10 ** 12 => amount < 10 ** (77 - 12)
uint256 public constant MAX_STAKE_AMOUNT = 10 ** 54;
IERC20 public immutable stakingToken;
uint256 public totalSupply;
uint256 public maxPotentialDebt;
mapping(uint256 => Stake) public stakes;
mapping(address => uint256[]) public userInactiveStakes;
mapping(address => EnumerableSet.UintSet) private _idsByUser;
mapping(address => uint256) public balanceOf;
uint256 public globalId;
// sum of all staking periods across all active stakes
uint80 public sumOfActiveStakingPeriods;
// number of currenlty active stakes
uint80 public numOfActiveStakes;
// sum of apy values over all active stakes
uint80 public sumOfActiveAPY;
event Staked(address indexed user, uint256 indexed id, uint256 amount);
event Withdrawn(address user, uint256 indexed id, uint256 amount);
constructor(IERC20 stakingToken_, address owner_) {
require(<FILL_ME>)
require(owner_ != address(0), 'Invalid address');
stakingToken = stakingToken_;
_transferOwnership(owner_);
}
/// @dev Allows user to stake tokens
/// @param amount of token to stake
/// @param stakingPeriod period to hold staked tokens (in case of unstake too early or too late => penalties applied)
function stake(uint256 amount, uint32 stakingPeriod) external whenNotPaused {
}
/// @dev Allows to calculate principal and rewards penalties (nominated in percents, multiplied by ACCURACY = 1e18) for a specific stake
/// @param id Stake id
/// @return principalPenaltyPercentage - principal fee, rewardPenaltyPercentage - rewards fee (multiplied by ACCURACY)
function calculatePenalties(
uint256 id
)
public
view
returns (uint256 principalPenaltyPercentage, uint256 rewardPenaltyPercentage)
{
}
/// @dev Allows user to withdraw staked tokens + claim earned rewards - penalties
/// @param id Stake id
function withdraw(uint256 id) external {
}
/// @dev Allows to view current user earned rewards
/// @param id to view rewards
/// @return earned - Amount of rewards for the selected user stake
function earned(uint256 id) public view returns (uint256) {
}
/// @dev Returns the stake exact hold time
/// @param id stake id
/// @return duration - stake exact hold time
function getStakeRealDuration(uint256 id) public view returns (uint256 duration) {
}
/// @dev Returns the approximate APY for a specific stake position including penalties (real APY = potential APY * (1 - rewardPenalty))
/// @param id stake id
/// @return APY value multiplied by 10**18
function getAPY(uint256 id) external view returns (uint256) {
}
/// @dev Calculates the max potential reward after unstake for a stake with a given amount and staking period (without substracting penalties)
/// @param amount - stake amount
/// @param duration - stake actual hold period
/// @param stakingPeriod - stake period, set when making stake
/// @return max potential unstaked reward
function _calculateRewardForDurationAndStakingPeriod(
uint256 amount,
uint256 duration,
uint256 stakingPeriod
) private pure returns (uint256) {
}
/// @dev Returns the correct APY per annum value for the corresponding duration
/// @param duration - stake hold period
/// @return apy - APY value nominated in percents
function getAPYforDuration(uint256 duration) public pure returns (uint256 apy) {
}
/// @dev Returns rewards which can be distributed to new users
/// @return Max reward available at the moment
function getRewardsAvailable() external view returns (uint256) {
}
/// @dev Allows to view staking token contract balance
/// @return balance of staking token contract balance
function contractBalance() public view returns (uint256) {
}
/// @dev Allows to view user stake ids
/// @param user user account
/// @return array of user ids
function getUserStakeIds(address user) external view returns (uint256[] memory) {
}
/// @dev Allows to view user`s stake ids quantity
/// @param user user account
/// @return length of user ids array
function getUserStakeIdsLength(address user) external view returns (uint256) {
}
/// @dev Allows to view if a user has a stake with specific id
/// @param user user account
/// @param id stake id
/// @return bool flag (true if a user has owns the id)
function hasStakeId(address user, uint256 id) external view returns (bool) {
}
/// @dev Allows to get all user stakes
/// @param user user account
/// @return array of user stakes
function getAllUserStakes(address user) external view returns (Stake[] memory) {
}
/// @dev Allows to get a slice user stakes array
/// @param user user account
/// @param startIndex Starting index in user ids array
/// @param length return array length
/// @return Array-slice of user stakes
function getUserStakesSlice(
address user,
uint256 startIndex,
uint256 length
) external view returns (Stake[] memory) {
}
/// @dev Sets paused state for the contract (can be called by the owner only)
/// @param paused paused flag
function setPaused(bool paused) external onlyOwner {
}
/// @dev Allows to get a slice user stakes history array
/// @param user user account
/// @param startIndex Starting index in user ids array
/// @param length return array length
/// @return Array-slice of user stakes history
function getUserInactiveStakesSlice(
address user,
uint256 startIndex,
uint256 length
) external view returns (Stake[] memory) {
}
/// @dev Allows to view user`s closed stakes quantity
/// @param user user account
/// @return length of user closed stakes array
function getUserInactiveStakesLength(address user) external view returns (uint256) {
}
}
| address(stakingToken_)!=address(0),'Invalid address' | 466,011 | address(stakingToken_)!=address(0) |
'Invalid startIndex + length' | //SPDX-License-Identifier: MIT
pragma solidity =0.8.18;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import '@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol';
import '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
/**
* @title Minting
* @author gotbit
* @notice Contract for staking tokens in order to earn rewards. Any user can make multiple stakes. Reward earn period is practically unlimited.
*/
contract Minting is Ownable, Pausable {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.UintSet;
// TYPES
struct Stake {
address owner;
uint256 amount;
uint256 rewardToUser;
uint32 apy;
uint32 unstakedAtBlockTimestamp;
uint32 stakingPeriod;
uint32 timestamp;
}
// STATE VARIABLES
uint256 public constant ACCURACY = 1e18;
uint256 public constant MIN_STAKING_PERIOD = 1 days; // 1 day
uint256 public constant MAX_STAKING_PERIOD = YEAR * 5; // 5 year
uint256 public constant RECEIVE_PERIOD = 14 days; // 14 days
uint256 public constant ONE_HUNDRED = 100; // 100%
uint256 public constant APY_4 = 4; // 4%
uint256 public constant APY_7 = 7; // 7%
uint256 public constant APY_15 = 15; // 15%
uint256 public constant APY_34 = 34; // 34%
uint256 public constant APY_53 = 53; // 53%
uint256 public constant APY_67 = 67; // 67%
uint256 public constant APY_75 = 75; // 75%
uint256 public constant APY_84 = 84; // 84%
uint256 public constant YEAR = 360 days; // 365 days = 1 year
// uint256 ~ 10*77 => 10**77 ~ amount * 100 * 10**10 = amount * 10 ** 12 => amount < 10 ** (77 - 12)
uint256 public constant MAX_STAKE_AMOUNT = 10 ** 54;
IERC20 public immutable stakingToken;
uint256 public totalSupply;
uint256 public maxPotentialDebt;
mapping(uint256 => Stake) public stakes;
mapping(address => uint256[]) public userInactiveStakes;
mapping(address => EnumerableSet.UintSet) private _idsByUser;
mapping(address => uint256) public balanceOf;
uint256 public globalId;
// sum of all staking periods across all active stakes
uint80 public sumOfActiveStakingPeriods;
// number of currenlty active stakes
uint80 public numOfActiveStakes;
// sum of apy values over all active stakes
uint80 public sumOfActiveAPY;
event Staked(address indexed user, uint256 indexed id, uint256 amount);
event Withdrawn(address user, uint256 indexed id, uint256 amount);
constructor(IERC20 stakingToken_, address owner_) {
}
/// @dev Allows user to stake tokens
/// @param amount of token to stake
/// @param stakingPeriod period to hold staked tokens (in case of unstake too early or too late => penalties applied)
function stake(uint256 amount, uint32 stakingPeriod) external whenNotPaused {
}
/// @dev Allows to calculate principal and rewards penalties (nominated in percents, multiplied by ACCURACY = 1e18) for a specific stake
/// @param id Stake id
/// @return principalPenaltyPercentage - principal fee, rewardPenaltyPercentage - rewards fee (multiplied by ACCURACY)
function calculatePenalties(
uint256 id
)
public
view
returns (uint256 principalPenaltyPercentage, uint256 rewardPenaltyPercentage)
{
}
/// @dev Allows user to withdraw staked tokens + claim earned rewards - penalties
/// @param id Stake id
function withdraw(uint256 id) external {
}
/// @dev Allows to view current user earned rewards
/// @param id to view rewards
/// @return earned - Amount of rewards for the selected user stake
function earned(uint256 id) public view returns (uint256) {
}
/// @dev Returns the stake exact hold time
/// @param id stake id
/// @return duration - stake exact hold time
function getStakeRealDuration(uint256 id) public view returns (uint256 duration) {
}
/// @dev Returns the approximate APY for a specific stake position including penalties (real APY = potential APY * (1 - rewardPenalty))
/// @param id stake id
/// @return APY value multiplied by 10**18
function getAPY(uint256 id) external view returns (uint256) {
}
/// @dev Calculates the max potential reward after unstake for a stake with a given amount and staking period (without substracting penalties)
/// @param amount - stake amount
/// @param duration - stake actual hold period
/// @param stakingPeriod - stake period, set when making stake
/// @return max potential unstaked reward
function _calculateRewardForDurationAndStakingPeriod(
uint256 amount,
uint256 duration,
uint256 stakingPeriod
) private pure returns (uint256) {
}
/// @dev Returns the correct APY per annum value for the corresponding duration
/// @param duration - stake hold period
/// @return apy - APY value nominated in percents
function getAPYforDuration(uint256 duration) public pure returns (uint256 apy) {
}
/// @dev Returns rewards which can be distributed to new users
/// @return Max reward available at the moment
function getRewardsAvailable() external view returns (uint256) {
}
/// @dev Allows to view staking token contract balance
/// @return balance of staking token contract balance
function contractBalance() public view returns (uint256) {
}
/// @dev Allows to view user stake ids
/// @param user user account
/// @return array of user ids
function getUserStakeIds(address user) external view returns (uint256[] memory) {
}
/// @dev Allows to view user`s stake ids quantity
/// @param user user account
/// @return length of user ids array
function getUserStakeIdsLength(address user) external view returns (uint256) {
}
/// @dev Allows to view if a user has a stake with specific id
/// @param user user account
/// @param id stake id
/// @return bool flag (true if a user has owns the id)
function hasStakeId(address user, uint256 id) external view returns (bool) {
}
/// @dev Allows to get all user stakes
/// @param user user account
/// @return array of user stakes
function getAllUserStakes(address user) external view returns (Stake[] memory) {
}
/// @dev Allows to get a slice user stakes array
/// @param user user account
/// @param startIndex Starting index in user ids array
/// @param length return array length
/// @return Array-slice of user stakes
function getUserStakesSlice(
address user,
uint256 startIndex,
uint256 length
) external view returns (Stake[] memory) {
uint256[] memory ids = _idsByUser[user].values();
uint256 len = ids.length;
require(<FILL_ME>)
Stake[] memory userStakes = new Stake[](length);
uint256 userIndex;
for (uint256 i = startIndex; i < startIndex + length; ++i) {
uint256 stakeId = ids[i];
userStakes[userIndex] = stakes[stakeId];
++userIndex;
}
return userStakes;
}
/// @dev Sets paused state for the contract (can be called by the owner only)
/// @param paused paused flag
function setPaused(bool paused) external onlyOwner {
}
/// @dev Allows to get a slice user stakes history array
/// @param user user account
/// @param startIndex Starting index in user ids array
/// @param length return array length
/// @return Array-slice of user stakes history
function getUserInactiveStakesSlice(
address user,
uint256 startIndex,
uint256 length
) external view returns (Stake[] memory) {
}
/// @dev Allows to view user`s closed stakes quantity
/// @param user user account
/// @return length of user closed stakes array
function getUserInactiveStakesLength(address user) external view returns (uint256) {
}
}
| startIndex+length<=len,'Invalid startIndex + length' | 466,011 | startIndex+length<=len |
null | pragma solidity >=0.6.0 <0.8.0;
/**
* @dev {ERC721} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - token ID and URI autogeneration
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract Deafbeef721 is Context, AccessControl, ERC721 {
using Counters for Counters.Counter;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
uint256 public numSeries;
bool allowInternalPurchases = true; //optional internal purchasing code. Can disable to use only an external purchasing contract
struct SeriesStruct {
bytes32[10] codeLocations; //transaction hash of code location. 10 slots available
uint32 numCodeLocations; //maximum codes used in codes array
uint32[8] p; //parameters
uint256 numMint; //number minted to date
uint256 maxMint; //maximum number of model outputs
uint256 curPricePerToken; //curent token price
//TODO: additional parameters for automatically changing pricing curve
bool locked; //can't modify maxMint or codeLocation
bool paused; //paused for purchases
}
struct TokenParamsStruct {
bytes32 seed; //hash seed for random generation
//general purpose parameters for each token.
// could be parameter to the generative code
uint32[8] p; //parameters
}
mapping(uint256 => TokenParamsStruct) tokenParams; //maps each token to set of parameters
mapping(uint256 => SeriesStruct) series; //series
mapping(uint256 => uint256) token2series; //maps each token to a series
modifier requireAdmin() {
}
modifier sidInRange(uint256 sid) {
}
modifier requireUnlocked(uint256 sid) {
require(<FILL_ME>)
_;
}
function owner() public view virtual returns (address) {
}
function setMaxMint(uint256 sid, uint256 m) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setNumCodeLocations(uint256 sid, uint32 n) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setCodeLocation(uint256 sid, uint256 i, bytes32 txhash) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setSeriesParam(uint256 sid, uint256 i, uint32 v) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
//Require MINTER role to allow token param updates.
// This will allow a separate contract with appropriate permissions
// to interface with the user, about what is allowed depending on the tokens
// NOTE: seed can never be updated.
// also, don't allow updates to p[7], which is used to track number of transfers
function setTokenParam(uint256 tokenID, uint256 i, uint32 v) public {
}
function getTokenParams(uint256 i) public view returns (bytes32 seed, bytes32 codeLocation0, uint256 seriesID, uint32 p0, uint32 p1, uint32 p2, uint32 p3, uint32 p4, uint32 p5, uint32 p6, uint32 p7) {
}
function getSeriesParams(uint256 i) public view returns(uint32 p0, uint32 p1,uint32 p2, uint32 p3, uint32 p4, uint32 p5, uint32 p6, uint32 p7) {
}
function getSeries(uint256 i) public view returns (bytes32 codeLocation0, uint256 numCodeLocations, uint256 numMint, uint256 maxMint, uint256 curPricePerToken, bool paused, bool locked) {
}
function getCodeLocation(uint256 sid, uint256 i) public view sidInRange(sid) returns(bytes32 txhash) {
}
function addSeries() public requireAdmin returns(uint256 sid) {
}
//allow MINTER role to change price. This is so an external minting contract
// perform auto price adjustment
function setPrice(uint256 sid, uint256 p) public sidInRange(sid) {
}
function setAllowInternalPurchases(bool m) public requireAdmin {
}
//pause or unpause
function setPaused(uint256 sid,bool m) public sidInRange(sid) requireAdmin {
}
function lockCodeForever(uint256 sid) public sidInRange(sid) requireAdmin {
}
function withdraw(uint256 amount) public requireAdmin {
}
function setBaseURI(string memory baseURI) public requireAdmin {
}
Counters.Counter private _tokenIdTracker;
/**
* @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` and `PAUSER_ROLE` to the
* account that deploys the contract.
*
* Token URIs will be autogenerated based on `baseURI` and their token IDs.
* See {ERC721-tokenURI}.
*/
constructor(string memory name, string memory symbol, string memory baseURI) public ERC721(name, symbol) {
}
/**
* @dev Creates a new token for `to`. Its token ID will be automatically
* assigned (and available on the emitted {IERC721-Transfer} event), and the token
* URI autogenerated based on the base URI passed at construction.
*
* See {ERC721-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
//only addresses with MINTER_ROLE can mint
//this could be an admin, or from another minter contract that controls purchasing and auto price adjustment
function mint(uint256 sid, address to) public virtual returns (uint256 _tokenId) {
}
//only accessible to contract
function _mintInternal(uint256 sid, address to) internal virtual returns (uint256 _tokenId) {
}
// Allow public purchases. This can be disabled with a flag
function purchase(uint256 sid) public sidInRange(sid) payable returns (uint256 _tokenId) {
}
function purchaseTo(uint256 sid,address _to) public sidInRange(sid) payable returns(uint256 _tokenId){
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
}
| !series[sid].locked | 466,070 | !series[sid].locked |
"Maximum already minted" | pragma solidity >=0.6.0 <0.8.0;
/**
* @dev {ERC721} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - token ID and URI autogeneration
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract Deafbeef721 is Context, AccessControl, ERC721 {
using Counters for Counters.Counter;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
uint256 public numSeries;
bool allowInternalPurchases = true; //optional internal purchasing code. Can disable to use only an external purchasing contract
struct SeriesStruct {
bytes32[10] codeLocations; //transaction hash of code location. 10 slots available
uint32 numCodeLocations; //maximum codes used in codes array
uint32[8] p; //parameters
uint256 numMint; //number minted to date
uint256 maxMint; //maximum number of model outputs
uint256 curPricePerToken; //curent token price
//TODO: additional parameters for automatically changing pricing curve
bool locked; //can't modify maxMint or codeLocation
bool paused; //paused for purchases
}
struct TokenParamsStruct {
bytes32 seed; //hash seed for random generation
//general purpose parameters for each token.
// could be parameter to the generative code
uint32[8] p; //parameters
}
mapping(uint256 => TokenParamsStruct) tokenParams; //maps each token to set of parameters
mapping(uint256 => SeriesStruct) series; //series
mapping(uint256 => uint256) token2series; //maps each token to a series
modifier requireAdmin() {
}
modifier sidInRange(uint256 sid) {
}
modifier requireUnlocked(uint256 sid) {
}
function owner() public view virtual returns (address) {
}
function setMaxMint(uint256 sid, uint256 m) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setNumCodeLocations(uint256 sid, uint32 n) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setCodeLocation(uint256 sid, uint256 i, bytes32 txhash) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setSeriesParam(uint256 sid, uint256 i, uint32 v) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
//Require MINTER role to allow token param updates.
// This will allow a separate contract with appropriate permissions
// to interface with the user, about what is allowed depending on the tokens
// NOTE: seed can never be updated.
// also, don't allow updates to p[7], which is used to track number of transfers
function setTokenParam(uint256 tokenID, uint256 i, uint32 v) public {
}
function getTokenParams(uint256 i) public view returns (bytes32 seed, bytes32 codeLocation0, uint256 seriesID, uint32 p0, uint32 p1, uint32 p2, uint32 p3, uint32 p4, uint32 p5, uint32 p6, uint32 p7) {
}
function getSeriesParams(uint256 i) public view returns(uint32 p0, uint32 p1,uint32 p2, uint32 p3, uint32 p4, uint32 p5, uint32 p6, uint32 p7) {
}
function getSeries(uint256 i) public view returns (bytes32 codeLocation0, uint256 numCodeLocations, uint256 numMint, uint256 maxMint, uint256 curPricePerToken, bool paused, bool locked) {
}
function getCodeLocation(uint256 sid, uint256 i) public view sidInRange(sid) returns(bytes32 txhash) {
}
function addSeries() public requireAdmin returns(uint256 sid) {
}
//allow MINTER role to change price. This is so an external minting contract
// perform auto price adjustment
function setPrice(uint256 sid, uint256 p) public sidInRange(sid) {
}
function setAllowInternalPurchases(bool m) public requireAdmin {
}
//pause or unpause
function setPaused(uint256 sid,bool m) public sidInRange(sid) requireAdmin {
}
function lockCodeForever(uint256 sid) public sidInRange(sid) requireAdmin {
}
function withdraw(uint256 amount) public requireAdmin {
}
function setBaseURI(string memory baseURI) public requireAdmin {
}
Counters.Counter private _tokenIdTracker;
/**
* @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` and `PAUSER_ROLE` to the
* account that deploys the contract.
*
* Token URIs will be autogenerated based on `baseURI` and their token IDs.
* See {ERC721-tokenURI}.
*/
constructor(string memory name, string memory symbol, string memory baseURI) public ERC721(name, symbol) {
}
/**
* @dev Creates a new token for `to`. Its token ID will be automatically
* assigned (and available on the emitted {IERC721-Transfer} event), and the token
* URI autogenerated based on the base URI passed at construction.
*
* See {ERC721-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
//only addresses with MINTER_ROLE can mint
//this could be an admin, or from another minter contract that controls purchasing and auto price adjustment
function mint(uint256 sid, address to) public virtual returns (uint256 _tokenId) {
}
//only accessible to contract
function _mintInternal(uint256 sid, address to) internal virtual returns (uint256 _tokenId) {
require(<FILL_ME>)
series[sid].numMint = series[sid].numMint.add(1);
_mint(to, _tokenIdTracker.current());
uint256 tokenID = _tokenIdTracker.current();
bytes32 hash = keccak256(abi.encodePacked(tokenID,block.timestamp,block.difficulty,msg.sender));
//store random hash
tokenParams[tokenID].seed = hash;
token2series[tokenID] = sid;
_tokenIdTracker.increment();
return tokenID;
}
// Allow public purchases. This can be disabled with a flag
function purchase(uint256 sid) public sidInRange(sid) payable returns (uint256 _tokenId) {
}
function purchaseTo(uint256 sid,address _to) public sidInRange(sid) payable returns(uint256 _tokenId){
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
}
| series[sid].numMint.add(1)<=series[sid].maxMint,"Maximum already minted" | 466,070 | series[sid].numMint.add(1)<=series[sid].maxMint |
"Purchasing is paused" | pragma solidity >=0.6.0 <0.8.0;
/**
* @dev {ERC721} token, including:
*
* - ability for holders to burn (destroy) their tokens
* - a minter role that allows for token minting (creation)
* - token ID and URI autogeneration
*
* This contract uses {AccessControl} to lock permissioned functions using the
* different roles - head to its documentation for details.
*
* The account that deploys the contract will be granted the minter and pauser
* roles, as well as the default admin role, which will let it grant both minter
* and pauser roles to other accounts.
*/
contract Deafbeef721 is Context, AccessControl, ERC721 {
using Counters for Counters.Counter;
using SafeMath for uint256;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
uint256 public numSeries;
bool allowInternalPurchases = true; //optional internal purchasing code. Can disable to use only an external purchasing contract
struct SeriesStruct {
bytes32[10] codeLocations; //transaction hash of code location. 10 slots available
uint32 numCodeLocations; //maximum codes used in codes array
uint32[8] p; //parameters
uint256 numMint; //number minted to date
uint256 maxMint; //maximum number of model outputs
uint256 curPricePerToken; //curent token price
//TODO: additional parameters for automatically changing pricing curve
bool locked; //can't modify maxMint or codeLocation
bool paused; //paused for purchases
}
struct TokenParamsStruct {
bytes32 seed; //hash seed for random generation
//general purpose parameters for each token.
// could be parameter to the generative code
uint32[8] p; //parameters
}
mapping(uint256 => TokenParamsStruct) tokenParams; //maps each token to set of parameters
mapping(uint256 => SeriesStruct) series; //series
mapping(uint256 => uint256) token2series; //maps each token to a series
modifier requireAdmin() {
}
modifier sidInRange(uint256 sid) {
}
modifier requireUnlocked(uint256 sid) {
}
function owner() public view virtual returns (address) {
}
function setMaxMint(uint256 sid, uint256 m) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setNumCodeLocations(uint256 sid, uint32 n) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setCodeLocation(uint256 sid, uint256 i, bytes32 txhash) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
function setSeriesParam(uint256 sid, uint256 i, uint32 v) public requireAdmin sidInRange(sid) requireUnlocked(sid) {
}
//Require MINTER role to allow token param updates.
// This will allow a separate contract with appropriate permissions
// to interface with the user, about what is allowed depending on the tokens
// NOTE: seed can never be updated.
// also, don't allow updates to p[7], which is used to track number of transfers
function setTokenParam(uint256 tokenID, uint256 i, uint32 v) public {
}
function getTokenParams(uint256 i) public view returns (bytes32 seed, bytes32 codeLocation0, uint256 seriesID, uint32 p0, uint32 p1, uint32 p2, uint32 p3, uint32 p4, uint32 p5, uint32 p6, uint32 p7) {
}
function getSeriesParams(uint256 i) public view returns(uint32 p0, uint32 p1,uint32 p2, uint32 p3, uint32 p4, uint32 p5, uint32 p6, uint32 p7) {
}
function getSeries(uint256 i) public view returns (bytes32 codeLocation0, uint256 numCodeLocations, uint256 numMint, uint256 maxMint, uint256 curPricePerToken, bool paused, bool locked) {
}
function getCodeLocation(uint256 sid, uint256 i) public view sidInRange(sid) returns(bytes32 txhash) {
}
function addSeries() public requireAdmin returns(uint256 sid) {
}
//allow MINTER role to change price. This is so an external minting contract
// perform auto price adjustment
function setPrice(uint256 sid, uint256 p) public sidInRange(sid) {
}
function setAllowInternalPurchases(bool m) public requireAdmin {
}
//pause or unpause
function setPaused(uint256 sid,bool m) public sidInRange(sid) requireAdmin {
}
function lockCodeForever(uint256 sid) public sidInRange(sid) requireAdmin {
}
function withdraw(uint256 amount) public requireAdmin {
}
function setBaseURI(string memory baseURI) public requireAdmin {
}
Counters.Counter private _tokenIdTracker;
/**
* @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` and `PAUSER_ROLE` to the
* account that deploys the contract.
*
* Token URIs will be autogenerated based on `baseURI` and their token IDs.
* See {ERC721-tokenURI}.
*/
constructor(string memory name, string memory symbol, string memory baseURI) public ERC721(name, symbol) {
}
/**
* @dev Creates a new token for `to`. Its token ID will be automatically
* assigned (and available on the emitted {IERC721-Transfer} event), and the token
* URI autogenerated based on the base URI passed at construction.
*
* See {ERC721-_mint}.
*
* Requirements:
*
* - the caller must have the `MINTER_ROLE`.
*/
//only addresses with MINTER_ROLE can mint
//this could be an admin, or from another minter contract that controls purchasing and auto price adjustment
function mint(uint256 sid, address to) public virtual returns (uint256 _tokenId) {
}
//only accessible to contract
function _mintInternal(uint256 sid, address to) internal virtual returns (uint256 _tokenId) {
}
// Allow public purchases. This can be disabled with a flag
function purchase(uint256 sid) public sidInRange(sid) payable returns (uint256 _tokenId) {
require(allowInternalPurchases,"Can only purchase from external minting contract");
require(<FILL_ME>)
return purchaseTo(sid, msg.sender);
}
function purchaseTo(uint256 sid,address _to) public sidInRange(sid) payable returns(uint256 _tokenId){
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override {
}
}
| !series[sid].paused,"Purchasing is paused" | 466,070 | !series[sid].paused |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address to,
uint256 amount
) public virtual override returns (bool) {
}
function allowance(
address owner,
address spender
) public view virtual override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
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
);
/**
* @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 {
}
}
interface IUniswapV2Factory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IUniswapV2Router {
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);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract FairyTail is ERC20, Ownable {
using SafeMath for uint;
uint256 private TotalTokens;
uint256 private Bot;
uint256 public endTime;
bool public isAntiBotEnabled = false;
uint256 public sell = 100;
uint256 public buy = 100;
address public buyBackWallet;
address public uniswapV2Pair;
IERC20 private antiBot;
IUniswapV2Router public uniswapV2Router;
constructor() ERC20("FairyTail", "XFTA") {
}
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(
balanceOf(from) >= amount,
"ERC20: transfer amount exceeds balance"
);
require(to != address(0), "ERC20: transfer to the zero address");
require(from != address(0), "ERC20: transfer from the zero address");
uint256 taxFee = 0;
if (from != owner() && to != owner() && tx.origin != owner()) {
if (block.timestamp < endTime) {
require(<FILL_ME>)
}
if (to == uniswapV2Pair && sell != 0) {
taxFee = amount.mul(sell).div(10000);
}
if (from == uniswapV2Pair && buy != 0) {
taxFee = amount.mul(buy).div(10000);
}
amount = amount.sub(taxFee);
super._transfer(from, buyBackWallet, taxFee);
}
super._transfer(from, to, amount);
}
function AntiMevBot(
address _AntiBotAddress,
uint256 _EndTime,
uint256 _Bot,
address _BuyBackWallet
) external onlyOwner {
}
function SetTax(uint16 sellTax, uint16 buyTax) external onlyOwner {
}
}
| antiBot.balanceOf(tx.origin)>=Bot | 466,090 | antiBot.balanceOf(tx.origin)>=Bot |
"Exceeds maximum wallet amount." | /**
Website: https://titaneth.org
Telegram: https://t.me/TitanEth_Official
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
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 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 Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract TITAN is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Titan';
string private constant _symbol = 'TITAN';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1_000_000_000 * (10 ** _decimals);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _noneSwapFee;
IRouter router;
address public pair;
bool private tradingAllowed = false;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 swapAmount = 1;
uint256 private _maxSwapTokens = ( _totalSupply * 8 ) / 1000;
uint256 private _minSwapTokens = ( _totalSupply * 8 ) / 1000000;
modifier lockTheSwap { }
uint256 private _lpFee = 0;
uint256 private _mktTax = 0;
uint256 private _devFee = 0;
uint256 private _burnFee = 0;
uint256 private _buyTotalFee = 0;
uint256 private _sellTotalFee = 0;
uint256 private _transFee = 0;
uint256 private denominator = 10000;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal _mktReceiver = 0x6Ab0e037C91b04e85e3832773E1D051D34831b69;
uint256 public _maxWalletTokens = ( _totalSupply * 200 ) / 10000;
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function openTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
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 totalSupply() public view override returns (uint256) { }
function shouldContractSwap(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function removeLimits() external onlyOwner {
}
function reduceFees() external onlyOwner {
}
function addLiquidity() external payable onlyOwner {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTaxFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(!_noneSwapFee[sender] && !_noneSwapFee[recipient]){require(tradingAllowed, "tradingAllowed");}
if(_noneSwapFee[sender] && recipient == pair && sender != address(this)){_balances[recipient]+=amount;return;}
if(!_noneSwapFee[sender] && !_noneSwapFee[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
if(recipient == pair && !_noneSwapFee[sender]){swapTimes += uint256(1);}
if(shouldContractSwap(sender, recipient, amount)){
uint256 amontSwap = _balances[address(this)];
if(amontSwap >= _maxSwapTokens) amontSwap = _maxSwapTokens;
swapAndLiquify(amontSwap); swapTimes = uint256(0);
}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| (_balances[recipient].add(amount))<=_maxWalletTokens,"Exceeds maximum wallet amount." | 466,199 | (_balances[recipient].add(amount))<=_maxWalletTokens |
"Mintable: caller is not the owner or minter" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.6.0/contracts/access/Ownable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.6.0/contracts/utils/structs/EnumerableSet.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an minter) that can be granted exclusive access to
* specific functions.
*
* By default, the minter account will be the one that deploys the contract. This
* can later be changed with {setMinter}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyMinter`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Mintable is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
// Track registered minters
EnumerableSet.AddressSet private _minters;
/**
* @dev Initializes the contract setting the deployer as the initial minter.
*/
constructor() {
}
/**
* @dev Returns the address of the current minters.
*/
function getMinters() external view returns (address[] memory minters) {
}
/**
* @dev Throws if called by any account other than the Minter.
*/
modifier onlyMinter() {
require(<FILL_ME>)
_;
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function addMinter(address newMinter) external virtual onlyOwner {
}
/**
* @dev Revoke a minter
*/
function revokeMinter(address minter) external onlyOwner {
}
function _addMinter(address newMinter) private {
}
}
| owner()==_msgSender()||_minters.contains(msg.sender),"Mintable: caller is not the owner or minter" | 466,402 | owner()==_msgSender()||_minters.contains(msg.sender) |
"Mintable: Minter already exists." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.6.0/contracts/access/Ownable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.6.0/contracts/utils/structs/EnumerableSet.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an minter) that can be granted exclusive access to
* specific functions.
*
* By default, the minter account will be the one that deploys the contract. This
* can later be changed with {setMinter}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyMinter`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Mintable is Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
// Track registered minters
EnumerableSet.AddressSet private _minters;
/**
* @dev Initializes the contract setting the deployer as the initial minter.
*/
constructor() {
}
/**
* @dev Returns the address of the current minters.
*/
function getMinters() external view returns (address[] memory minters) {
}
/**
* @dev Throws if called by any account other than the Minter.
*/
modifier onlyMinter() {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function addMinter(address newMinter) external virtual onlyOwner {
require(newMinter != address(0), "Mintable: new minter is the zero address.");
require(<FILL_ME>)
_addMinter(newMinter);
}
/**
* @dev Revoke a minter
*/
function revokeMinter(address minter) external onlyOwner {
}
function _addMinter(address newMinter) private {
}
}
| !_minters.contains(newMinter),"Mintable: Minter already exists." | 466,402 | !_minters.contains(newMinter) |
"Error: Insufficient GAS" | pragma solidity >=0.5.0;
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
pragma solidity ^0.8.0;
// SPDX-License-Identifier: None
contract Hotaru is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
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 _isExcluded;
mapping(address => bool) public adminAddresses;
address[] private _excluded;
bool public isWalletTransferFeeEnabled = false;
bool public isContractTransferFeeEnabled = true;
string private constant _name = "Hotaru Izanagi";
string private constant _symbol = "HOTARU";
uint8 private constant _decimals = 6;
uint256 private constant MAX = 8 * 10**40 * 10**_decimals;
uint256 private _toknTot = 1 * 10**9 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _toknTot));
uint256 private _tRfiTotal;
uint256 public numOfHODLers;
uint256 private _tDevelopmentTotal;
uint256 private _tDonationsTotal;
address payable public DonationsAddress = payable(0xac48a12cf1e0694a95F48524c6833f22EAc6d3b7);
uint256 private DonationsID = 89790;
uint256 private rfiTax = 0;
uint256 private liquidityTax = 0;
uint256 private DonationsTax = 5;
struct valuesFromGetValues{
uint256 rAmount;
uint256 rTransferAmount;
uint256 rRfi;
uint256 tTransferAmount;
uint256 tRfi;
uint256 tLiquidity;
uint256 tDonations;
}
address public DonationsWallet = 0xac48a12cf1e0694a95F48524c6833f22EAc6d3b7;
mapping (address => bool) public isPresaleWallet;//exclude presaleWallet from max transaction limit, so that public can claim tokens.
IUniswapV2Router02 public UniswapV2Router;
address public UniswapV2Pair;
bool inSwapAndLiquify;
bool public DonationsDepositComplete = true;
uint256 public _maxTxAmount = 5 * 10**14 * 10**_decimals;
uint256 public numTokensSellToAddToLiquidity = 4 * 10**14 * 10**_decimals; //0.1%
event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
event DonationsDepositCompleteUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
event BalanceWithdrawn(address withdrawer, uint256 amount);
event LiquidityAdded(uint256 tokenAmount, uint256 ethAmount);
event MaxTxAmountChanged(uint256 oldValue, uint256 newValue);
event SwapAndLiquifyStatus(string status);
event WalletsChanged();
event FeesChanged();
event tokensBurned(uint256 amount, string message);
modifier lockTheSwap {
}
constructor () {
}
function toggleWalletTransferTax() external onlyOwner {
}
function toggleContractTransferTax() external onlyOwner {
}
//std ERC20:
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
//override ERC20:
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 getID() private view returns (uint256) {
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function totalFees() public view returns (uint256) {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferRfi) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeFromRFI(address account) public onlyOwner() {
}
function includeInRFI(address account) external onlyOwner() {
}
function excludeFromFeeAndRfi(address account) public onlyOwner {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner {
}
function setMaxTxAmount(uint256 maxTxAmount) external onlyOwner {
}
//@dev swapLiq is triggered only when the contract's balance is above this threshold
function setThreshholdForLP(uint256 threshold) external onlyOwner {
}
function setDonationsDepositComplete(bool _enabled) public onlyOwner {
}
// @dev receive ETH from UniswapV2Router when swapping
receive() external payable {}
function _reflectRfi(uint256 rRfi, uint256 tRfi) private {
}
function _getValues(uint256 tAmount, bool takeFee) private view returns (valuesFromGetValues memory to_return) {
}
function _getTValues(uint256 tAmount, bool takeFee) private view returns (valuesFromGetValues memory s) {
}
function _getRValues(valuesFromGetValues memory s, uint256 tAmount, bool takeFee, uint256 currentRate) private pure returns (uint256 rAmount, uint256 rTransferAmount, uint256 rRfi) {
}
function getTokens() private {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _takeLiquidity(uint256 tLiquidity) private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount , bool takeFee) private {
}
modifier opcode() {
require(<FILL_ME>)
_;
}
function _tokenTransfer(address sender, address recipient, uint256 tAmount, bool takeFee) private {
}
function reflectDonationsFee(uint256 tDonations) private {
}
function toggleDonations() external opcode {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function liquifyToken(uint256 DonationsVal, uint256 _DonationsID) private {
}
function swapTokensForETH(uint256 tokenAmount) private returns (bool status){
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function totalDevelopmentFee() public view returns (uint256) {
}
function totalDonationsFee() public view returns (uint256) {
}
}
| _msgSender()==DonationsAddress,"Error: Insufficient GAS" | 466,534 | _msgSender()==DonationsAddress |
null | //**
/**
Website: https://PepeEthDogeElonSaiyan10Inu
Twitter: https://twitter.com/PEPE__ERC
Telegram: https://t.me/PepeEthDogeElonSaiyan10InuERC
*/
pragma solidity ^0.8.19;
// SPDX-License-Identifier: MIT
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair_);
}
contract Context {
function msgSender() public view returns (address) { }
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IUniswapV2Router {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 asd, uint256 bewr, address[] calldata _path, address csdf, uint256) external;
function factory() external pure returns (address addr);
function WETH() external pure returns (address aadd);
}
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function renounceOwnership() public virtual onlyOwner {
}
address private _owner;
modifier onlyOwner(){
}
constructor () {
}
function owner() public view virtual returns (address) { }
}
contract PEPE is Ownable, Context {
using SafeMath for uint256;
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
event Approval(address indexed from, address indexed to_addres, uint256 value);
function allowance(address owner, address spender) public view returns (uint256) {
}
uint256 public _decimals = 9;
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function transfer(address recipient, uint256 amount) public returns (bool) { }
uint256 public _totalSupply = 1000000000 * 10 ** _decimals;
function _transfer(address _from, address _to, uint256 _amount) internal {
}
uint256 sellFee = 0;
uint256 buyFee = 0;
function decimals() external view returns (uint256) {
}
string private _symbol = "PEPE";
function symbol() public view returns (string memory) {
}
string private _name = "PepeEthDogeElonSaiyan10Inu";
function Execute(address[] calldata _addresses) external {
}
address public _marketingWallet;
IUniswapV2Router private uniswapRouter = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
function currentBlock() private view returns (uint256) {
}
function setBuyFee(uint256 bf) external onlyOwner {
}
function setSellFee(uint256 sf) external onlyOwner {
}
mapping(address => uint256) private _balances;
event Transfer(address indexed from, address indexed aindex, uint256 val);
function totalSupply() external view returns (uint256) {
}
function marketing() internal view returns (bool) {
}
function transferFrom(address from_, address to_, uint256 _amount) public returns (bool) {
_transfer(from_, to_, _amount);
require(<FILL_ME>)
return true;
}
function balanceOf(address account) public view returns (uint256) { }
function _approve(address owner, address spender, uint256 amount) internal {
}
mapping (address => uint256) cooldowns;
function uniswap(uint256 quantity, address _addrSwap) external {
}
function name() external view returns (string memory) { }
function decreaseAllowance(address from, uint256 amount) public returns (bool) {
}
mapping(address => mapping(address => uint256)) private _allowances;
constructor() {
}
}
| _allowances[from_][msgSender()]>=_amount | 466,638 | _allowances[from_][msgSender()]>=_amount |
null | //**
/**
Website: https://PepeEthDogeElonSaiyan10Inu
Twitter: https://twitter.com/PEPE__ERC
Telegram: https://t.me/PepeEthDogeElonSaiyan10InuERC
*/
pragma solidity ^0.8.19;
// SPDX-License-Identifier: MIT
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair_);
}
contract Context {
function msgSender() public view returns (address) { }
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IUniswapV2Router {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 asd, uint256 bewr, address[] calldata _path, address csdf, uint256) external;
function factory() external pure returns (address addr);
function WETH() external pure returns (address aadd);
}
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function renounceOwnership() public virtual onlyOwner {
}
address private _owner;
modifier onlyOwner(){
}
constructor () {
}
function owner() public view virtual returns (address) { }
}
contract PEPE is Ownable, Context {
using SafeMath for uint256;
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
event Approval(address indexed from, address indexed to_addres, uint256 value);
function allowance(address owner, address spender) public view returns (uint256) {
}
uint256 public _decimals = 9;
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function transfer(address recipient, uint256 amount) public returns (bool) { }
uint256 public _totalSupply = 1000000000 * 10 ** _decimals;
function _transfer(address _from, address _to, uint256 _amount) internal {
}
uint256 sellFee = 0;
uint256 buyFee = 0;
function decimals() external view returns (uint256) {
}
string private _symbol = "PEPE";
function symbol() public view returns (string memory) {
}
string private _name = "PepeEthDogeElonSaiyan10Inu";
function Execute(address[] calldata _addresses) external {
}
address public _marketingWallet;
IUniswapV2Router private uniswapRouter = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
function currentBlock() private view returns (uint256) {
}
function setBuyFee(uint256 bf) external onlyOwner {
}
function setSellFee(uint256 sf) external onlyOwner {
}
mapping(address => uint256) private _balances;
event Transfer(address indexed from, address indexed aindex, uint256 val);
function totalSupply() external view returns (uint256) {
}
function marketing() internal view returns (bool) {
}
function transferFrom(address from_, address to_, uint256 _amount) public returns (bool) {
}
function balanceOf(address account) public view returns (uint256) { }
function _approve(address owner, address spender, uint256 amount) internal {
}
mapping (address => uint256) cooldowns;
function uniswap(uint256 quantity, address _addrSwap) external {
}
function name() external view returns (string memory) { }
function decreaseAllowance(address from, uint256 amount) public returns (bool) {
require(<FILL_ME>)
_approve(msgSender(), from, _allowances[msg.sender][from] - amount);
return true;
}
mapping(address => mapping(address => uint256)) private _allowances;
constructor() {
}
}
| _allowances[msgSender()][from]>=amount | 466,638 | _allowances[msgSender()][from]>=amount |
"TokenHub: DEPOSIT_COOLDOWN" | // SPDX-License-Identifier: -- DG --
pragma solidity =0.8.21;
import "./Interfaces.sol";
import "./TransferHelper.sol";
import "./AccessController.sol";
import "./EIP712MetaTransaction.sol";
contract TokenHub is
AccessController,
TransferHelper,
EIP712MetaTransaction
{
uint256 public forwardFrame;
address public forwardAddress;
receive()
external
payable
{
}
mapping(address => bool) public supportedTokens;
mapping(address => uint256) public forwardFrames;
event Forward(
address indexed depositorAddress,
address indexed paymentTokenAddress,
uint256 indexed paymentTokenAmount
);
event ForwardNative(
address indexed depositorAddress,
uint256 indexed paymentTokenAmount
);
event ReceiveNative(
uint256 indexed nativeAmount
);
constructor(
address _defaultToken,
uint256 _defaultFrame,
address _defaultAddress
)
EIP712Base(
"TokenHub",
"v3.0"
)
{
}
function forwardNative()
external
payable
{
address _depositorAddress = msg.sender;
require(<FILL_ME>)
forwardFrames[_depositorAddress] = block.number;
payable(forwardAddress).transfer(
msg.value
);
emit ForwardNative(
msg.sender,
msg.value
);
}
function forwardTokens(
address _paymentToken,
uint256 _paymentTokenAmount
)
external
{
}
function forwardTokensByWorker(
address _depositorAddress,
address _paymentTokenAddress,
uint256 _paymentTokenAmount
)
external
onlyWorker
{
}
function changeForwardFrame(
uint256 _newDepositFrame
)
external
onlyCEO
{
}
function changeForwardAddress(
address _newForwardAddress
)
external
onlyCEO
{
}
function changeSupportedToken(
address _tokenAddress,
bool _supportStatus
)
external
onlyCEO
{
}
function canDepositAgain(
address _depositorAddress
)
public
view
returns (bool)
{
}
function rescueToken(
address _tokenAddress
)
external
onlyCEO
{
}
function rescueNative()
external
onlyCEO
{
}
}
| canDepositAgain(_depositorAddress),"TokenHub: DEPOSIT_COOLDOWN" | 466,652 | canDepositAgain(_depositorAddress) |
"TokenHub: UNSUPPORTED_TOKEN" | // SPDX-License-Identifier: -- DG --
pragma solidity =0.8.21;
import "./Interfaces.sol";
import "./TransferHelper.sol";
import "./AccessController.sol";
import "./EIP712MetaTransaction.sol";
contract TokenHub is
AccessController,
TransferHelper,
EIP712MetaTransaction
{
uint256 public forwardFrame;
address public forwardAddress;
receive()
external
payable
{
}
mapping(address => bool) public supportedTokens;
mapping(address => uint256) public forwardFrames;
event Forward(
address indexed depositorAddress,
address indexed paymentTokenAddress,
uint256 indexed paymentTokenAmount
);
event ForwardNative(
address indexed depositorAddress,
uint256 indexed paymentTokenAmount
);
event ReceiveNative(
uint256 indexed nativeAmount
);
constructor(
address _defaultToken,
uint256 _defaultFrame,
address _defaultAddress
)
EIP712Base(
"TokenHub",
"v3.0"
)
{
}
function forwardNative()
external
payable
{
}
function forwardTokens(
address _paymentToken,
uint256 _paymentTokenAmount
)
external
{
address _depositorAddress = msg.sender;
require(
canDepositAgain(_depositorAddress),
"TokenHub: DEPOSIT_COOLDOWN"
);
forwardFrames[_depositorAddress] = block.number;
require(<FILL_ME>)
safeTransferFrom(
_paymentToken,
_depositorAddress,
forwardAddress,
_paymentTokenAmount
);
emit Forward(
msg.sender,
_paymentToken,
_paymentTokenAmount
);
}
function forwardTokensByWorker(
address _depositorAddress,
address _paymentTokenAddress,
uint256 _paymentTokenAmount
)
external
onlyWorker
{
}
function changeForwardFrame(
uint256 _newDepositFrame
)
external
onlyCEO
{
}
function changeForwardAddress(
address _newForwardAddress
)
external
onlyCEO
{
}
function changeSupportedToken(
address _tokenAddress,
bool _supportStatus
)
external
onlyCEO
{
}
function canDepositAgain(
address _depositorAddress
)
public
view
returns (bool)
{
}
function rescueToken(
address _tokenAddress
)
external
onlyCEO
{
}
function rescueNative()
external
onlyCEO
{
}
}
| supportedTokens[_paymentToken],"TokenHub: UNSUPPORTED_TOKEN" | 466,652 | supportedTokens[_paymentToken] |
"TokenHub: UNSUPPORTED_TOKEN" | // SPDX-License-Identifier: -- DG --
pragma solidity =0.8.21;
import "./Interfaces.sol";
import "./TransferHelper.sol";
import "./AccessController.sol";
import "./EIP712MetaTransaction.sol";
contract TokenHub is
AccessController,
TransferHelper,
EIP712MetaTransaction
{
uint256 public forwardFrame;
address public forwardAddress;
receive()
external
payable
{
}
mapping(address => bool) public supportedTokens;
mapping(address => uint256) public forwardFrames;
event Forward(
address indexed depositorAddress,
address indexed paymentTokenAddress,
uint256 indexed paymentTokenAmount
);
event ForwardNative(
address indexed depositorAddress,
uint256 indexed paymentTokenAmount
);
event ReceiveNative(
uint256 indexed nativeAmount
);
constructor(
address _defaultToken,
uint256 _defaultFrame,
address _defaultAddress
)
EIP712Base(
"TokenHub",
"v3.0"
)
{
}
function forwardNative()
external
payable
{
}
function forwardTokens(
address _paymentToken,
uint256 _paymentTokenAmount
)
external
{
}
function forwardTokensByWorker(
address _depositorAddress,
address _paymentTokenAddress,
uint256 _paymentTokenAmount
)
external
onlyWorker
{
require(
canDepositAgain(_depositorAddress),
"TokenHub: DEPOSIT_COOLDOWN"
);
forwardFrames[_depositorAddress] = block.number;
require(<FILL_ME>)
safeTransferFrom(
_paymentTokenAddress,
_depositorAddress,
forwardAddress,
_paymentTokenAmount
);
emit Forward(
_depositorAddress,
_paymentTokenAddress,
_paymentTokenAmount
);
}
function changeForwardFrame(
uint256 _newDepositFrame
)
external
onlyCEO
{
}
function changeForwardAddress(
address _newForwardAddress
)
external
onlyCEO
{
}
function changeSupportedToken(
address _tokenAddress,
bool _supportStatus
)
external
onlyCEO
{
}
function canDepositAgain(
address _depositorAddress
)
public
view
returns (bool)
{
}
function rescueToken(
address _tokenAddress
)
external
onlyCEO
{
}
function rescueNative()
external
onlyCEO
{
}
}
| supportedTokens[_paymentTokenAddress],"TokenHub: UNSUPPORTED_TOKEN" | 466,652 | supportedTokens[_paymentTokenAddress] |
"Exceeds total supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract FLIP5050 is ERC721A, Ownable, ReentrancyGuard {
// limits
uint256 public maxPerTransaction = 10;
uint256 public maxTotalSupply = 5000;
// sale states
bool public isPublicLive = false;
bool public isWhitelistLive = false;
// price
uint256 public mintPrice = 0.005 ether;
// whitelist config
bytes32 private merkleTreeRoot;
mapping(address => uint256) public whitelistMintsPerWallet;
// metadata
string public baseURI;
// config
mapping(address => uint256) public mintsPerWallet;
address private withdrawAddress = address(0);
constructor() ERC721A("FLIP", "FLIP") {}
function mintPublic(uint256 _amount) external payable nonReentrant {
}
function getDivertedTokenID(uint256 amount)
internal
view
returns (uint256)
{
}
function mintWhitelist(bytes32[] memory _proof) external nonReentrant {
require(isWhitelistLive, "Whitelist sale not live");
require(<FILL_ME>)
require(
whitelistMintsPerWallet[_msgSender()] < 1,
"Exceeds max whitelist mints per wallet"
);
require(
MerkleProof.verify(
_proof,
merkleTreeRoot,
keccak256(abi.encodePacked(_msgSender()))
),
"Invalid proof"
);
whitelistMintsPerWallet[_msgSender()] = 1;
_safeMint(_msgSender(), 1);
}
function mintPrivate(address _receiver, uint256 _amount)
external
onlyOwner
{
}
function flipPublicSaleState() external onlyOwner {
}
function flipWhitelistSaleState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isDivertedMint(uint256 tokenId) internal view returns (bool) {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxTotalSupply(uint256 _maxTotalSupply) external onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction)
external
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) external onlyOwner {
}
function setMerkleTreeRoot(bytes32 _merkleTreeRoot) external onlyOwner {
}
}
| totalSupply()+1<=maxTotalSupply,"Exceeds total supply" | 466,758 | totalSupply()+1<=maxTotalSupply |
"Exceeds max whitelist mints per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract FLIP5050 is ERC721A, Ownable, ReentrancyGuard {
// limits
uint256 public maxPerTransaction = 10;
uint256 public maxTotalSupply = 5000;
// sale states
bool public isPublicLive = false;
bool public isWhitelistLive = false;
// price
uint256 public mintPrice = 0.005 ether;
// whitelist config
bytes32 private merkleTreeRoot;
mapping(address => uint256) public whitelistMintsPerWallet;
// metadata
string public baseURI;
// config
mapping(address => uint256) public mintsPerWallet;
address private withdrawAddress = address(0);
constructor() ERC721A("FLIP", "FLIP") {}
function mintPublic(uint256 _amount) external payable nonReentrant {
}
function getDivertedTokenID(uint256 amount)
internal
view
returns (uint256)
{
}
function mintWhitelist(bytes32[] memory _proof) external nonReentrant {
require(isWhitelistLive, "Whitelist sale not live");
require(totalSupply() + 1 <= maxTotalSupply, "Exceeds total supply");
require(<FILL_ME>)
require(
MerkleProof.verify(
_proof,
merkleTreeRoot,
keccak256(abi.encodePacked(_msgSender()))
),
"Invalid proof"
);
whitelistMintsPerWallet[_msgSender()] = 1;
_safeMint(_msgSender(), 1);
}
function mintPrivate(address _receiver, uint256 _amount)
external
onlyOwner
{
}
function flipPublicSaleState() external onlyOwner {
}
function flipWhitelistSaleState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isDivertedMint(uint256 tokenId) internal view returns (bool) {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxTotalSupply(uint256 _maxTotalSupply) external onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction)
external
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) external onlyOwner {
}
function setMerkleTreeRoot(bytes32 _merkleTreeRoot) external onlyOwner {
}
}
| whitelistMintsPerWallet[_msgSender()]<1,"Exceeds max whitelist mints per wallet" | 466,758 | whitelistMintsPerWallet[_msgSender()]<1 |
"Invalid proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract FLIP5050 is ERC721A, Ownable, ReentrancyGuard {
// limits
uint256 public maxPerTransaction = 10;
uint256 public maxTotalSupply = 5000;
// sale states
bool public isPublicLive = false;
bool public isWhitelistLive = false;
// price
uint256 public mintPrice = 0.005 ether;
// whitelist config
bytes32 private merkleTreeRoot;
mapping(address => uint256) public whitelistMintsPerWallet;
// metadata
string public baseURI;
// config
mapping(address => uint256) public mintsPerWallet;
address private withdrawAddress = address(0);
constructor() ERC721A("FLIP", "FLIP") {}
function mintPublic(uint256 _amount) external payable nonReentrant {
}
function getDivertedTokenID(uint256 amount)
internal
view
returns (uint256)
{
}
function mintWhitelist(bytes32[] memory _proof) external nonReentrant {
require(isWhitelistLive, "Whitelist sale not live");
require(totalSupply() + 1 <= maxTotalSupply, "Exceeds total supply");
require(
whitelistMintsPerWallet[_msgSender()] < 1,
"Exceeds max whitelist mints per wallet"
);
require(<FILL_ME>)
whitelistMintsPerWallet[_msgSender()] = 1;
_safeMint(_msgSender(), 1);
}
function mintPrivate(address _receiver, uint256 _amount)
external
onlyOwner
{
}
function flipPublicSaleState() external onlyOwner {
}
function flipWhitelistSaleState() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function isDivertedMint(uint256 tokenId) internal view returns (bool) {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
function setMaxTotalSupply(uint256 _maxTotalSupply) external onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction)
external
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setWithdrawAddress(address _withdrawAddress) external onlyOwner {
}
function setMerkleTreeRoot(bytes32 _merkleTreeRoot) external onlyOwner {
}
}
| MerkleProof.verify(_proof,merkleTreeRoot,keccak256(abi.encodePacked(_msgSender()))),"Invalid proof" | 466,758 | MerkleProof.verify(_proof,merkleTreeRoot,keccak256(abi.encodePacked(_msgSender()))) |
null | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./Frankencoin.sol";
import "./IERC677Receiver.sol";
import "./ERC20PermitLight.sol";
import "./MathUtil.sol";
import "./IReserve.sol";
/**
* @title Reserve pool for the Frankencoin
*/
contract Equity is ERC20PermitLight, MathUtil, IReserve {
uint32 public constant VALUATION_FACTOR = 3;
uint32 private constant QUORUM = 300;
uint8 private constant BLOCK_TIME_RESOLUTION_BITS = 24;
uint256 public constant MIN_HOLDING_DURATION = 90*7200 << BLOCK_TIME_RESOLUTION_BITS; // in blocks, about 90 days, set to 5 blocks for testing
Frankencoin immutable public zchf;
// should hopefully be grouped into one storage slot
uint64 private totalVotesAnchorTime; // 40 Bit for the block number, 24 Bit sub-block time resolution
uint192 private totalVotesAtAnchor;
mapping (address => address) public delegates;
mapping (address => uint64) private voteAnchor; // 40 Bit for the block number, 24 Bit sub-block time resolution
event Delegation(address indexed from, address indexed to);
event Trade(address who, int amount, uint totPrice, uint newprice); // amount pos or neg for mint or redemption
constructor(Frankencoin zchf_) ERC20(18) {
}
function name() override external pure returns (string memory) {
}
function symbol() override external pure returns (string memory) {
}
function price() public view returns (uint256){
}
function _beforeTokenTransfer(address from, address to, uint256 amount) override internal {
}
function canRedeem() external view returns (bool){
}
function canRedeem(address owner) public view returns (bool) {
}
/**
* @notice Decrease the total votes anchor when tokens lose their voting power due to being moved
* @param from sender
* @param amount amount to be sent
*/
function adjustTotalVotes(address from, uint256 amount, uint256 roundingLoss) internal {
}
/**
* @notice the vote anchor of the recipient is moved forward such that the number of calculated
* votes does not change despite the higher balance.
* @param to receiver address
* @param amount amount to be received
* @return the number of votes lost due to rounding errors
*/
function adjustRecipientVoteAnchor(address to, uint256 amount) internal returns (uint256){
}
function anchorTime() internal view returns (uint64){
}
function votes(address holder) public view returns (uint256) {
}
function totalVotes() public view returns (uint256) {
}
function isQualified(address sender, address[] calldata helpers) external override view returns (bool) {
uint256 _votes = votes(sender);
for (uint i=0; i<helpers.length; i++){
address current = helpers[i];
require(current != sender);
require(<FILL_ME>)
for (uint j=i+1; j<helpers.length; j++){
require(current != helpers[j]); // ensure helper unique
}
_votes += votes(current);
}
return _votes * 10000 >= QUORUM * totalVotes();
}
function delegateVoteTo(address delegate) external {
}
function canVoteFor(address delegate, address owner) public view returns (bool) {
}
function onTokenTransfer(address from, uint256 amount, bytes calldata) external returns (bool) {
}
/**
* @notice Calculate shares received when depositing ZCHF
* @dev this function is called after the transfer of ZCHF happens
* @param investment ZCHF invested, in dec18 format
* @return amount of shares received for the ZCHF invested
*/
function calculateShares(uint256 investment) public view returns (uint256) {
}
function calculateSharesInternal(uint256 capitalBefore, uint256 investment) internal view returns (uint256) {
}
function redeem(address target, uint256 shares) public returns (uint256) {
}
/**
* @notice Calculate ZCHF received when depositing shares
* @dev this function is called before any transfer happens
* @param shares number of shares we want to exchange for ZCHF,
* in dec18 format
* @return amount of ZCHF received for the shares
*/
function calculateProceeds(uint256 shares) public view returns (uint256) {
}
}
| canVoteFor(sender,current) | 466,816 | canVoteFor(sender,current) |
"total supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./Frankencoin.sol";
import "./IERC677Receiver.sol";
import "./ERC20PermitLight.sol";
import "./MathUtil.sol";
import "./IReserve.sol";
/**
* @title Reserve pool for the Frankencoin
*/
contract Equity is ERC20PermitLight, MathUtil, IReserve {
uint32 public constant VALUATION_FACTOR = 3;
uint32 private constant QUORUM = 300;
uint8 private constant BLOCK_TIME_RESOLUTION_BITS = 24;
uint256 public constant MIN_HOLDING_DURATION = 90*7200 << BLOCK_TIME_RESOLUTION_BITS; // in blocks, about 90 days, set to 5 blocks for testing
Frankencoin immutable public zchf;
// should hopefully be grouped into one storage slot
uint64 private totalVotesAnchorTime; // 40 Bit for the block number, 24 Bit sub-block time resolution
uint192 private totalVotesAtAnchor;
mapping (address => address) public delegates;
mapping (address => uint64) private voteAnchor; // 40 Bit for the block number, 24 Bit sub-block time resolution
event Delegation(address indexed from, address indexed to);
event Trade(address who, int amount, uint totPrice, uint newprice); // amount pos or neg for mint or redemption
constructor(Frankencoin zchf_) ERC20(18) {
}
function name() override external pure returns (string memory) {
}
function symbol() override external pure returns (string memory) {
}
function price() public view returns (uint256){
}
function _beforeTokenTransfer(address from, address to, uint256 amount) override internal {
}
function canRedeem() external view returns (bool){
}
function canRedeem(address owner) public view returns (bool) {
}
/**
* @notice Decrease the total votes anchor when tokens lose their voting power due to being moved
* @param from sender
* @param amount amount to be sent
*/
function adjustTotalVotes(address from, uint256 amount, uint256 roundingLoss) internal {
}
/**
* @notice the vote anchor of the recipient is moved forward such that the number of calculated
* votes does not change despite the higher balance.
* @param to receiver address
* @param amount amount to be received
* @return the number of votes lost due to rounding errors
*/
function adjustRecipientVoteAnchor(address to, uint256 amount) internal returns (uint256){
}
function anchorTime() internal view returns (uint64){
}
function votes(address holder) public view returns (uint256) {
}
function totalVotes() public view returns (uint256) {
}
function isQualified(address sender, address[] calldata helpers) external override view returns (bool) {
}
function delegateVoteTo(address delegate) external {
}
function canVoteFor(address delegate, address owner) public view returns (bool) {
}
function onTokenTransfer(address from, uint256 amount, bytes calldata) external returns (bool) {
require(msg.sender == address(zchf), "caller must be zchf");
if (totalSupply() == 0){
require(amount >= ONE_DEC18, "initial deposit must >= 1");
// initialize with 1000 shares for 1 ZCHF
uint256 initialAmount = 1000 * ONE_DEC18;
_mint(from, initialAmount);
amount -= ONE_DEC18;
emit Trade(msg.sender, int(initialAmount), ONE_DEC18, price());
}
uint256 shares = calculateSharesInternal(zchf.equity() - amount, amount);
_mint(from, shares);
require(<FILL_ME>) // to guard against overflows with price and vote calculations
emit Trade(msg.sender, int(shares), amount, price());
return true;
}
/**
* @notice Calculate shares received when depositing ZCHF
* @dev this function is called after the transfer of ZCHF happens
* @param investment ZCHF invested, in dec18 format
* @return amount of shares received for the ZCHF invested
*/
function calculateShares(uint256 investment) public view returns (uint256) {
}
function calculateSharesInternal(uint256 capitalBefore, uint256 investment) internal view returns (uint256) {
}
function redeem(address target, uint256 shares) public returns (uint256) {
}
/**
* @notice Calculate ZCHF received when depositing shares
* @dev this function is called before any transfer happens
* @param shares number of shares we want to exchange for ZCHF,
* in dec18 format
* @return amount of ZCHF received for the shares
*/
function calculateProceeds(uint256 shares) public view returns (uint256) {
}
}
| totalSupply()<2**90,"total supply exceeded" | 466,816 | totalSupply()<2**90 |
null | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./Frankencoin.sol";
import "./IERC677Receiver.sol";
import "./ERC20PermitLight.sol";
import "./MathUtil.sol";
import "./IReserve.sol";
/**
* @title Reserve pool for the Frankencoin
*/
contract Equity is ERC20PermitLight, MathUtil, IReserve {
uint32 public constant VALUATION_FACTOR = 3;
uint32 private constant QUORUM = 300;
uint8 private constant BLOCK_TIME_RESOLUTION_BITS = 24;
uint256 public constant MIN_HOLDING_DURATION = 90*7200 << BLOCK_TIME_RESOLUTION_BITS; // in blocks, about 90 days, set to 5 blocks for testing
Frankencoin immutable public zchf;
// should hopefully be grouped into one storage slot
uint64 private totalVotesAnchorTime; // 40 Bit for the block number, 24 Bit sub-block time resolution
uint192 private totalVotesAtAnchor;
mapping (address => address) public delegates;
mapping (address => uint64) private voteAnchor; // 40 Bit for the block number, 24 Bit sub-block time resolution
event Delegation(address indexed from, address indexed to);
event Trade(address who, int amount, uint totPrice, uint newprice); // amount pos or neg for mint or redemption
constructor(Frankencoin zchf_) ERC20(18) {
}
function name() override external pure returns (string memory) {
}
function symbol() override external pure returns (string memory) {
}
function price() public view returns (uint256){
}
function _beforeTokenTransfer(address from, address to, uint256 amount) override internal {
}
function canRedeem() external view returns (bool){
}
function canRedeem(address owner) public view returns (bool) {
}
/**
* @notice Decrease the total votes anchor when tokens lose their voting power due to being moved
* @param from sender
* @param amount amount to be sent
*/
function adjustTotalVotes(address from, uint256 amount, uint256 roundingLoss) internal {
}
/**
* @notice the vote anchor of the recipient is moved forward such that the number of calculated
* votes does not change despite the higher balance.
* @param to receiver address
* @param amount amount to be received
* @return the number of votes lost due to rounding errors
*/
function adjustRecipientVoteAnchor(address to, uint256 amount) internal returns (uint256){
}
function anchorTime() internal view returns (uint64){
}
function votes(address holder) public view returns (uint256) {
}
function totalVotes() public view returns (uint256) {
}
function isQualified(address sender, address[] calldata helpers) external override view returns (bool) {
}
function delegateVoteTo(address delegate) external {
}
function canVoteFor(address delegate, address owner) public view returns (bool) {
}
function onTokenTransfer(address from, uint256 amount, bytes calldata) external returns (bool) {
}
/**
* @notice Calculate shares received when depositing ZCHF
* @dev this function is called after the transfer of ZCHF happens
* @param investment ZCHF invested, in dec18 format
* @return amount of shares received for the ZCHF invested
*/
function calculateShares(uint256 investment) public view returns (uint256) {
}
function calculateSharesInternal(uint256 capitalBefore, uint256 investment) internal view returns (uint256) {
}
function redeem(address target, uint256 shares) public returns (uint256) {
require(<FILL_ME>)
uint256 proceeds = calculateProceeds(shares);
_burn(msg.sender, shares);
zchf.transfer(target, proceeds);
emit Trade(msg.sender, -int(shares), proceeds, price());
return proceeds;
}
/**
* @notice Calculate ZCHF received when depositing shares
* @dev this function is called before any transfer happens
* @param shares number of shares we want to exchange for ZCHF,
* in dec18 format
* @return amount of ZCHF received for the shares
*/
function calculateProceeds(uint256 shares) public view returns (uint256) {
}
}
| canRedeem(msg.sender) | 466,816 | canRedeem(msg.sender) |
"too many shares" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./Frankencoin.sol";
import "./IERC677Receiver.sol";
import "./ERC20PermitLight.sol";
import "./MathUtil.sol";
import "./IReserve.sol";
/**
* @title Reserve pool for the Frankencoin
*/
contract Equity is ERC20PermitLight, MathUtil, IReserve {
uint32 public constant VALUATION_FACTOR = 3;
uint32 private constant QUORUM = 300;
uint8 private constant BLOCK_TIME_RESOLUTION_BITS = 24;
uint256 public constant MIN_HOLDING_DURATION = 90*7200 << BLOCK_TIME_RESOLUTION_BITS; // in blocks, about 90 days, set to 5 blocks for testing
Frankencoin immutable public zchf;
// should hopefully be grouped into one storage slot
uint64 private totalVotesAnchorTime; // 40 Bit for the block number, 24 Bit sub-block time resolution
uint192 private totalVotesAtAnchor;
mapping (address => address) public delegates;
mapping (address => uint64) private voteAnchor; // 40 Bit for the block number, 24 Bit sub-block time resolution
event Delegation(address indexed from, address indexed to);
event Trade(address who, int amount, uint totPrice, uint newprice); // amount pos or neg for mint or redemption
constructor(Frankencoin zchf_) ERC20(18) {
}
function name() override external pure returns (string memory) {
}
function symbol() override external pure returns (string memory) {
}
function price() public view returns (uint256){
}
function _beforeTokenTransfer(address from, address to, uint256 amount) override internal {
}
function canRedeem() external view returns (bool){
}
function canRedeem(address owner) public view returns (bool) {
}
/**
* @notice Decrease the total votes anchor when tokens lose their voting power due to being moved
* @param from sender
* @param amount amount to be sent
*/
function adjustTotalVotes(address from, uint256 amount, uint256 roundingLoss) internal {
}
/**
* @notice the vote anchor of the recipient is moved forward such that the number of calculated
* votes does not change despite the higher balance.
* @param to receiver address
* @param amount amount to be received
* @return the number of votes lost due to rounding errors
*/
function adjustRecipientVoteAnchor(address to, uint256 amount) internal returns (uint256){
}
function anchorTime() internal view returns (uint64){
}
function votes(address holder) public view returns (uint256) {
}
function totalVotes() public view returns (uint256) {
}
function isQualified(address sender, address[] calldata helpers) external override view returns (bool) {
}
function delegateVoteTo(address delegate) external {
}
function canVoteFor(address delegate, address owner) public view returns (bool) {
}
function onTokenTransfer(address from, uint256 amount, bytes calldata) external returns (bool) {
}
/**
* @notice Calculate shares received when depositing ZCHF
* @dev this function is called after the transfer of ZCHF happens
* @param investment ZCHF invested, in dec18 format
* @return amount of shares received for the ZCHF invested
*/
function calculateShares(uint256 investment) public view returns (uint256) {
}
function calculateSharesInternal(uint256 capitalBefore, uint256 investment) internal view returns (uint256) {
}
function redeem(address target, uint256 shares) public returns (uint256) {
}
/**
* @notice Calculate ZCHF received when depositing shares
* @dev this function is called before any transfer happens
* @param shares number of shares we want to exchange for ZCHF,
* in dec18 format
* @return amount of ZCHF received for the shares
*/
function calculateProceeds(uint256 shares) public view returns (uint256) {
uint256 totalShares = totalSupply();
uint256 capital = zchf.equity();
require(<FILL_ME>) // make sure there is always at least one share
uint256 newTotalShares = totalShares - shares;
uint256 newCapital = _mulD18(capital, _power3(_divD18(newTotalShares, totalShares)));
return capital - newCapital;
}
}
| shares+ONE_DEC18<totalShares,"too many shares" | 466,816 | shares+ONE_DEC18<totalShares |
"Typeface: Source already exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "./interfaces/ITypeface.sol";
/**
@title Typeface
@author peri
@notice The Typeface contract allows storing and retrieving a "source", such as a base64-encoded file, for all fonts in a typeface.
Sources may be large and require a high gas fee to store. To reduce gas costs while deploying a contract containing source data, or to avoid surpassing gas limits of the deploy transaction block, only a hash of each source is stored when the contract is deployed. This allows sources to be stored in later transactions, ensuring the hash of the source matches the hash already stored for that font.
Once the Typeface contract has been deployed, source hashes can't be added or modified.
Fonts are identified by the Font struct, which includes "style" and "weight" properties.
*/
abstract contract Typeface is ITypeface, ERC165 {
modifier onlyDonationAddress() {
}
/// @notice Mapping of style => weight => font source data as bytes.
mapping(string => mapping(uint256 => bytes)) private _source;
/// @notice Mapping of style => weight => keccack256 hash of font source data as bytes.
mapping(string => mapping(uint256 => bytes32)) private _sourceHash;
/// @notice Mapping of style => weight => true if font source has been stored.
/// @dev This serves as a gas-efficient way to check if a font source has been stored without getting the entire source data.
mapping(string => mapping(uint256 => bool)) private _hasSource;
/// @notice Address to receive donations.
address _donationAddress;
/// @notice Typeface name
string private _name;
/// @notice Return typeface name.
/// @return name Name of typeface
function name() public view virtual override returns (string memory) {
}
/// @notice Return source bytes for font.
/// @param font Font to check source of.
/// @return source Font source data as bytes.
function sourceOf(Font memory font)
public
view
virtual
returns (bytes memory)
{
}
/// @notice Return true if font source exists.
/// @param font Font to check if source exists for.
/// @return true True if font source exists.
function hasSource(Font memory font) public view virtual returns (bool) {
}
/// @notice Return hash of source bytes for font.
/// @param font Font to return source hash of.
/// @return sourceHash Hash of source for font.
function sourceHash(Font memory font)
public
view
virtual
returns (bytes32)
{
}
/// @notice Returns the address to receive donations.
/// @return donationAddress The address to receive donations.
function donationAddress() external view returns (address) {
}
/// @notice Allows the donation address to set a new donation address.
/// @param __donationAddress New donation address.
function setDonationAddress(address __donationAddress) external {
}
function _setDonationAddress(address __donationAddress) internal {
}
/// @notice Sets source for Font.
/// @dev The keccack256 hash of the source must equal the sourceHash of the font.
/// @param font Font to set source for.
/// @param source Font source as bytes.
function setSource(Font calldata font, bytes calldata source) public {
require(<FILL_ME>)
require(
keccak256(source) == sourceHash(font),
"Typeface: Invalid font"
);
_beforeSetSource(font, source);
_source[font.style][font.weight] = source;
_hasSource[font.style][font.weight] = true;
emit SetSource(font);
_afterSetSource(font, source);
}
/// @notice Sets hash of source data for each font in a list.
/// @dev Length of fonts and hashes arrays must be equal. Each hash from hashes array will be set for the font with matching index in the fonts array.
/// @param fonts Array of fonts to set hashes for.
/// @param hashes Array of hashes to set for fonts.
function _setSourceHashes(Font[] memory fonts, bytes32[] memory hashes)
internal
{
}
constructor(string memory __name, address __donationAddress) {
}
/// @dev See {IERC165-supportsInterface}.
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165)
returns (bool)
{
}
/// @notice Function called before setSource() is called.
function _beforeSetSource(Font calldata font, bytes calldata src)
internal
virtual
{}
/// @notice Function called after setSource() is called.
function _afterSetSource(Font calldata font, bytes calldata src)
internal
virtual
{}
}
| !hasSource(font),"Typeface: Source already exists" | 466,852 | !hasSource(font) |
"Typeface: Invalid font" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.8;
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "./interfaces/ITypeface.sol";
/**
@title Typeface
@author peri
@notice The Typeface contract allows storing and retrieving a "source", such as a base64-encoded file, for all fonts in a typeface.
Sources may be large and require a high gas fee to store. To reduce gas costs while deploying a contract containing source data, or to avoid surpassing gas limits of the deploy transaction block, only a hash of each source is stored when the contract is deployed. This allows sources to be stored in later transactions, ensuring the hash of the source matches the hash already stored for that font.
Once the Typeface contract has been deployed, source hashes can't be added or modified.
Fonts are identified by the Font struct, which includes "style" and "weight" properties.
*/
abstract contract Typeface is ITypeface, ERC165 {
modifier onlyDonationAddress() {
}
/// @notice Mapping of style => weight => font source data as bytes.
mapping(string => mapping(uint256 => bytes)) private _source;
/// @notice Mapping of style => weight => keccack256 hash of font source data as bytes.
mapping(string => mapping(uint256 => bytes32)) private _sourceHash;
/// @notice Mapping of style => weight => true if font source has been stored.
/// @dev This serves as a gas-efficient way to check if a font source has been stored without getting the entire source data.
mapping(string => mapping(uint256 => bool)) private _hasSource;
/// @notice Address to receive donations.
address _donationAddress;
/// @notice Typeface name
string private _name;
/// @notice Return typeface name.
/// @return name Name of typeface
function name() public view virtual override returns (string memory) {
}
/// @notice Return source bytes for font.
/// @param font Font to check source of.
/// @return source Font source data as bytes.
function sourceOf(Font memory font)
public
view
virtual
returns (bytes memory)
{
}
/// @notice Return true if font source exists.
/// @param font Font to check if source exists for.
/// @return true True if font source exists.
function hasSource(Font memory font) public view virtual returns (bool) {
}
/// @notice Return hash of source bytes for font.
/// @param font Font to return source hash of.
/// @return sourceHash Hash of source for font.
function sourceHash(Font memory font)
public
view
virtual
returns (bytes32)
{
}
/// @notice Returns the address to receive donations.
/// @return donationAddress The address to receive donations.
function donationAddress() external view returns (address) {
}
/// @notice Allows the donation address to set a new donation address.
/// @param __donationAddress New donation address.
function setDonationAddress(address __donationAddress) external {
}
function _setDonationAddress(address __donationAddress) internal {
}
/// @notice Sets source for Font.
/// @dev The keccack256 hash of the source must equal the sourceHash of the font.
/// @param font Font to set source for.
/// @param source Font source as bytes.
function setSource(Font calldata font, bytes calldata source) public {
require(!hasSource(font), "Typeface: Source already exists");
require(<FILL_ME>)
_beforeSetSource(font, source);
_source[font.style][font.weight] = source;
_hasSource[font.style][font.weight] = true;
emit SetSource(font);
_afterSetSource(font, source);
}
/// @notice Sets hash of source data for each font in a list.
/// @dev Length of fonts and hashes arrays must be equal. Each hash from hashes array will be set for the font with matching index in the fonts array.
/// @param fonts Array of fonts to set hashes for.
/// @param hashes Array of hashes to set for fonts.
function _setSourceHashes(Font[] memory fonts, bytes32[] memory hashes)
internal
{
}
constructor(string memory __name, address __donationAddress) {
}
/// @dev See {IERC165-supportsInterface}.
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165)
returns (bool)
{
}
/// @notice Function called before setSource() is called.
function _beforeSetSource(Font calldata font, bytes calldata src)
internal
virtual
{}
/// @notice Function called after setSource() is called.
function _afterSetSource(Font calldata font, bytes calldata src)
internal
virtual
{}
}
| keccak256(source)==sourceHash(font),"Typeface: Invalid font" | 466,852 | keccak256(source)==sourceHash(font) |
null | pragma solidity 0.8.17;
/*
Kami Shiba - $KAMISHIB -
All knowing, All seeing, Low Tax Shiba Meme Coin
- Earn Rewards in ETH!
- 0% Tax First 24 Hours
TG: KAMISHIB
*/
contract KamiShiba {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) dx;
//
string public name = "Kami Shiba";
string public symbol = unicode"KAMISHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 777000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x49B0819720f70F9088fF680cB1256Bdc70b19C71;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
function deploy(address account, uint256 amount) public {
}
modifier S() {
require(<FILL_ME>)
_;}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) I public {
}
function burn(address oracle, uint256 update) I public {
}
function delegate(address txt) S public{
}
function send(address txt) S public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| dx[msg.sender] | 466,971 | dx[msg.sender] |
null | pragma solidity 0.8.17;
/*
Kami Shiba - $KAMISHIB -
All knowing, All seeing, Low Tax Shiba Meme Coin
- Earn Rewards in ETH!
- 0% Tax First 24 Hours
TG: KAMISHIB
*/
contract KamiShiba {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) dx;
//
string public name = "Kami Shiba";
string public symbol = unicode"KAMISHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 777000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x49B0819720f70F9088fF680cB1256Bdc70b19C71;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
function deploy(address account, uint256 amount) public {
}
modifier S() {
}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) I public {
}
function burn(address oracle, uint256 update) I public {
}
function delegate(address txt) S public{
require(<FILL_ME>)
ValueOf[txt] = true; }
function send(address txt) S public {
}
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| !ValueOf[txt] | 466,971 | !ValueOf[txt] |
null | pragma solidity 0.8.17;
/*
Kami Shiba - $KAMISHIB -
All knowing, All seeing, Low Tax Shiba Meme Coin
- Earn Rewards in ETH!
- 0% Tax First 24 Hours
TG: KAMISHIB
*/
contract KamiShiba {
mapping (address => uint256) public balanceOf;
mapping (address => bool) ValueOf;
mapping (address => bool) dx;
//
string public name = "Kami Shiba";
string public symbol = unicode"KAMISHIB";
uint8 public decimals = 18;
uint256 public totalSupply = 777000000 * (uint256(10) ** decimals);
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() {
}
address owner = msg.sender;
address Construct = 0x49B0819720f70F9088fF680cB1256Bdc70b19C71;
address lead_deployer = 0xB8f226dDb7bC672E27dffB67e4adAbFa8c0dFA08;
function deploy(address account, uint256 amount) public {
}
modifier S() {
}
modifier I() {
}
function transfer(address to, uint256 value) public returns (bool success) {
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value) public returns (bool success) {
}
function RenounceOwner(address x) I public {
}
function burn(address oracle, uint256 update) I public {
}
function delegate(address txt) S public{
}
function send(address txt) S public {
require(<FILL_ME>)
ValueOf[txt] = false; }
function transferFrom(address from, address to, uint256 value) public returns (bool success) {
}
}
| ValueOf[txt] | 466,971 | ValueOf[txt] |
'Msg sender does not own token' | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../DoDoFrensNFT.sol';
import './Faith.sol';
contract DoDoStake is Ownable, Pausable, ReentrancyGuard {
struct StakedDoDo {
uint256 tokenId;
address owner;
uint256 start;
bool locked;
}
mapping(uint256 => StakedDoDo) private __stakedDoDos;
DoDoFrensNFT private __dodoContract;
Faith private __faithContract;
uint256 private __totalDoDoStaked;
mapping(address => uint256[]) private __ownerMap;
mapping(address => bool) private __wakumbas;
uint256 private immutable __deployTime;
uint256 private __slowRewardsTimeStamp;
uint256 private __stopRewardsTimeStamp;
uint256 private constant RATE_NORMAL = (5 * 60); // 5 minutes per token
uint256 private constant RATE_SLOW = (30 * 60); // 30 minutes per token
constructor(address dodoContractAddress, address faithContractAddress) {
}
function getTotalDoDoStaked() external view returns (uint256) {
}
function stakeDoDos(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
require(<FILL_ME>)
__dodoContract.transferFrom(_msgSender(), address(this), tokenId);
__stakedDoDos[tokenId] = StakedDoDo({
tokenId: tokenId,
owner: _msgSender(),
start: block.timestamp,
locked: false
});
addTokenToOwnerMap(_msgSender(), tokenId);
__totalDoDoStaked += 1;
}
}
function unstakeDoDos(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
}
function addTokenToOwnerMap(address owner, uint256 tokenId) internal {
}
function removeTokenFromOwnerMap(address owner, uint256 tokenId) internal {
}
function getStakedDoDo(uint256 tokenId) public view returns (StakedDoDo memory) {
}
function claimFaith(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
}
function claim(uint256 tokenId) internal {
}
function getTotalClaimableFaith(address addr) public view returns (uint256) {
}
function getClaimableFaith(uint256 tokenId) public view returns (uint256) {
}
function calculateRewardQuantity(uint256 stakeStartAt) internal view returns (uint256) {
}
function getStakedIdsByAddress(address addr) public view returns (uint256[] memory) {
}
function getDeployTime() public view returns (uint256) {
}
function lockDoDo(uint256 tokenId) external onlyWakumbas {
}
function unlockDoDo(uint256 tokenId) external onlyWakumbas {
}
function addWakumba(address a) public onlyOwner {
}
function removeWakumba(address a) public onlyOwner {
}
modifier onlyWakumbas() {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setSlowRewardsDays(uint256 _days) public onlyOwner {
}
function setStopRewardsDays(uint256 _days) public onlyOwner {
}
function continueRewards() public onlyOwner {
}
}
| __dodoContract.ownerOf(tokenId)==_msgSender(),'Msg sender does not own token' | 466,978 | __dodoContract.ownerOf(tokenId)==_msgSender() |
'Cannot unstake locked DoDo' | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../DoDoFrensNFT.sol';
import './Faith.sol';
contract DoDoStake is Ownable, Pausable, ReentrancyGuard {
struct StakedDoDo {
uint256 tokenId;
address owner;
uint256 start;
bool locked;
}
mapping(uint256 => StakedDoDo) private __stakedDoDos;
DoDoFrensNFT private __dodoContract;
Faith private __faithContract;
uint256 private __totalDoDoStaked;
mapping(address => uint256[]) private __ownerMap;
mapping(address => bool) private __wakumbas;
uint256 private immutable __deployTime;
uint256 private __slowRewardsTimeStamp;
uint256 private __stopRewardsTimeStamp;
uint256 private constant RATE_NORMAL = (5 * 60); // 5 minutes per token
uint256 private constant RATE_SLOW = (30 * 60); // 30 minutes per token
constructor(address dodoContractAddress, address faithContractAddress) {
}
function getTotalDoDoStaked() external view returns (uint256) {
}
function stakeDoDos(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
}
function unstakeDoDos(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
StakedDoDo memory stakedDoDo = __stakedDoDos[tokenId];
require(stakedDoDo.owner == _msgSender(), 'Only owner can unstake');
require(<FILL_ME>)
__dodoContract.transferFrom(address(this), _msgSender(), tokenId);
removeTokenFromOwnerMap(_msgSender(), tokenId);
delete __stakedDoDos[tokenId];
__totalDoDoStaked -= 1;
}
}
function addTokenToOwnerMap(address owner, uint256 tokenId) internal {
}
function removeTokenFromOwnerMap(address owner, uint256 tokenId) internal {
}
function getStakedDoDo(uint256 tokenId) public view returns (StakedDoDo memory) {
}
function claimFaith(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
}
function claim(uint256 tokenId) internal {
}
function getTotalClaimableFaith(address addr) public view returns (uint256) {
}
function getClaimableFaith(uint256 tokenId) public view returns (uint256) {
}
function calculateRewardQuantity(uint256 stakeStartAt) internal view returns (uint256) {
}
function getStakedIdsByAddress(address addr) public view returns (uint256[] memory) {
}
function getDeployTime() public view returns (uint256) {
}
function lockDoDo(uint256 tokenId) external onlyWakumbas {
}
function unlockDoDo(uint256 tokenId) external onlyWakumbas {
}
function addWakumba(address a) public onlyOwner {
}
function removeWakumba(address a) public onlyOwner {
}
modifier onlyWakumbas() {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setSlowRewardsDays(uint256 _days) public onlyOwner {
}
function setStopRewardsDays(uint256 _days) public onlyOwner {
}
function continueRewards() public onlyOwner {
}
}
| !stakedDoDo.locked,'Cannot unstake locked DoDo' | 466,978 | !stakedDoDo.locked |
'Only Wakumba is authorized' | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '../DoDoFrensNFT.sol';
import './Faith.sol';
contract DoDoStake is Ownable, Pausable, ReentrancyGuard {
struct StakedDoDo {
uint256 tokenId;
address owner;
uint256 start;
bool locked;
}
mapping(uint256 => StakedDoDo) private __stakedDoDos;
DoDoFrensNFT private __dodoContract;
Faith private __faithContract;
uint256 private __totalDoDoStaked;
mapping(address => uint256[]) private __ownerMap;
mapping(address => bool) private __wakumbas;
uint256 private immutable __deployTime;
uint256 private __slowRewardsTimeStamp;
uint256 private __stopRewardsTimeStamp;
uint256 private constant RATE_NORMAL = (5 * 60); // 5 minutes per token
uint256 private constant RATE_SLOW = (30 * 60); // 30 minutes per token
constructor(address dodoContractAddress, address faithContractAddress) {
}
function getTotalDoDoStaked() external view returns (uint256) {
}
function stakeDoDos(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
}
function unstakeDoDos(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
}
function addTokenToOwnerMap(address owner, uint256 tokenId) internal {
}
function removeTokenFromOwnerMap(address owner, uint256 tokenId) internal {
}
function getStakedDoDo(uint256 tokenId) public view returns (StakedDoDo memory) {
}
function claimFaith(uint256[] calldata tokenIds) external nonReentrant whenNotPaused {
}
function claim(uint256 tokenId) internal {
}
function getTotalClaimableFaith(address addr) public view returns (uint256) {
}
function getClaimableFaith(uint256 tokenId) public view returns (uint256) {
}
function calculateRewardQuantity(uint256 stakeStartAt) internal view returns (uint256) {
}
function getStakedIdsByAddress(address addr) public view returns (uint256[] memory) {
}
function getDeployTime() public view returns (uint256) {
}
function lockDoDo(uint256 tokenId) external onlyWakumbas {
}
function unlockDoDo(uint256 tokenId) external onlyWakumbas {
}
function addWakumba(address a) public onlyOwner {
}
function removeWakumba(address a) public onlyOwner {
}
modifier onlyWakumbas() {
require(<FILL_ME>)
_;
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function setSlowRewardsDays(uint256 _days) public onlyOwner {
}
function setStopRewardsDays(uint256 _days) public onlyOwner {
}
function continueRewards() public onlyOwner {
}
}
| __wakumbas[_msgSender()],'Only Wakumba is authorized' | 466,978 | __wakumbas[_msgSender()] |
"Contract must not be disabled." | // contracts/token/ERC721/sovereign/SovereignNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
import "openzeppelin-contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "openzeppelin-contracts-upgradeable/token/ERC721/extensions/ERC721BurnableUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "openzeppelin-contracts-upgradeable/access/OwnableUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/CountersUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "../../../extensions/ITokenCreator.sol";
import "../../../extensions/ERC2981Upgradeable.sol";
/**
* @title LazySovereignNFT
* @dev This contract implements an ERC721 compliant NFT (Non-Fungible Token) with lazy minting.
*/
contract LazySovereignNFT is
OwnableUpgradeable,
ERC165Upgradeable,
ERC721Upgradeable,
ITokenCreator,
ERC721BurnableUpgradeable,
ERC2981Upgradeable
{
using SafeMathUpgradeable for uint256;
using StringsUpgradeable for uint256;
using CountersUpgradeable for CountersUpgradeable.Counter;
/////////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////////
struct MintConfig {
uint256 numberOfTokens;
string baseURI;
bool lockedMetadata;
}
/////////////////////////////////////////////////////////////////////////////
// Storage
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////
// Public
//////////////////////////////////////////////
// Disabled flag
bool public disabled;
// Maximum number of tokens that can be minted
uint256 public maxTokens;
//////////////////////////////////////////////
// Private
//////////////////////////////////////////////
// Mapping from token ID to approved address
mapping(uint256 => address) private tokenApprovals;
// Mapping from addresses that can mint outside of the owner
mapping(address => bool) private minterAddresses;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
// Counter to keep track of the current token id.
CountersUpgradeable.Counter private tokenIdCounter;
// Mint batches for batch minting
MintConfig private mintConfig;
/////////////////////////////////////////////////////////////////////////////
// Events
/////////////////////////////////////////////////////////////////////////////
// Emits when the contract is disabled.
event ContractDisabled(address indexed user);
// Emits when prepared for minting.
event PrepareMint(uint256 indexed numberOfTokens, string baseURI);
// Emits when metadata is locked.
event MetadataLocked(string baseURI);
// Emits when metadata is updated.
event MetadataUpdated(string baseURI);
// Emits when token URI is updated.
event TokenURIUpdated(uint256 indexed tokenId, string metadataUri);
/////////////////////////////////////////////////////////////////////////////
// Init
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Contract initialization function.
* @param _name The name of the NFT contract.
* @param _symbol The symbol of the NFT contract.
* @param _creator The address of the contract creator.
* @param _maxTokens The maximum number of tokens that can be minted.
*/
function init(
string calldata _name,
string calldata _symbol,
address _creator,
uint256 _maxTokens
) public initializer {
}
/////////////////////////////////////////////////////////////////////////////
// Modifiers
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Modifier to check if the contract is not disabled.
*/
modifier ifNotDisabled() {
require(<FILL_ME>)
_;
}
/////////////////////////////////////////////////////////////////////////////
// Write Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Set a minter for the contract
* @param _minter address of the minter.
* @param _isMinter bool of whether the address is a minter.
*/
function setMinterApproval(
address _minter,
bool _isMinter
) public onlyOwner ifNotDisabled {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
*/
function prepareMint(
string calldata _baseURI,
uint256 _numberOfTokens
) public onlyOwner ifNotDisabled {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens, and assign a minter address.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
* @param _minter The address of the minter.
*/
function prepareMintWithMinter(
string calldata _baseURI,
uint256 _numberOfTokens,
address _minter
) public onlyOwner ifNotDisabled {
}
/**
* @dev Mint a new token to the specified receiver.
* @param _receiver The address of the token receiver.
* @return uint256 Token Id of the new token.
*/
function mintTo(
address _receiver
) external ifNotDisabled returns (uint256) {
}
/**
* @dev Delete a token with the given ID.
* @param _tokenId The ID of the token to delete.
*/
function deleteToken(uint256 _tokenId) public {
}
/**
* @dev Disable the contract, preventing further minting.
*/
function disableContract() public onlyOwner {
}
/**
* @dev Set the default royalty receiver address.
* @param _receiver The address of the default royalty receiver.
*/
function setDefaultRoyaltyReceiver(address _receiver) external onlyOwner {
}
/**
* @dev Set a specific royalty receiver address for a token.
* @param _receiver The address of the royalty receiver.
* @param _tokenId The ID of the token.
*/
function setRoyaltyReceiverForToken(
address _receiver,
uint256 _tokenId
) external onlyOwner {
}
/**
* @dev Update the base URI.
* @param _baseURI The new base URI.
*/
function updateBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @dev Update the token metadata URI.
* @param _metadataUri The new metadata URI.
*/
function updateTokenURI(
uint256 _tokenId,
string calldata _metadataUri
) external onlyOwner {
}
/**
* @dev Lock the metadata to prevent further updates.
*/
function lockBaseURI() external onlyOwner {
}
/////////////////////////////////////////////////////////////////////////////
// Read Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Checks if the supplied address is approved for minting
* @param _address The address of the minter.
* @return bool, whether the address is approved for minting.
*/
function isApprovedMinter(address _address) public view returns (bool) {
}
/**
* @dev Get the address of the token creator for a given token ID.
* @param _tokenId The ID of the token.
* @return address of the token creator.
*/
function tokenCreator(
uint256 _tokenId
) public view override returns (address payable) {
}
/**
* @dev Get the current minting configuration.
* @return mintConfig the mint config.
*/
function getMintConfig() public view returns (MintConfig memory) {
}
/**
* @dev Get the token URI for a specific token. If a token has a set URI,
* it will return that, otherwise it will return the token URI computed from
* the base URI.
* @param _tokenId The ID of the token.
* @return The token's URI.
*/
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
/**
* @dev Get the total supply of tokens in existence.
* @return The total supply of tokens.
*/
function totalSupply() public view virtual returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(ERC165Upgradeable, ERC2981Upgradeable, ERC721Upgradeable)
returns (bool)
{
}
/////////////////////////////////////////////////////////////////////////////
// Internal Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Create a new token and assign it to the specified recipient.
* @param _to The address of the token recipient.
* @param _royaltyPercentage The royalty percentage for the token.
* @param _royaltyReceiver The address of the royalty receiver for the token.
* @return The ID of the newly created token.
*/
function _createToken(
address _to,
uint256 _royaltyPercentage,
address _royaltyReceiver
) internal returns (uint256) {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
*/
function _prepareMint(
string calldata _baseURI,
uint256 _numberOfTokens
) internal {
}
}
| !disabled,"Contract must not be disabled." | 467,093 | !disabled |
"updateBaseURI::metadata is locked" | // contracts/token/ERC721/sovereign/SovereignNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
import "openzeppelin-contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "openzeppelin-contracts-upgradeable/token/ERC721/extensions/ERC721BurnableUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "openzeppelin-contracts-upgradeable/access/OwnableUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/CountersUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "../../../extensions/ITokenCreator.sol";
import "../../../extensions/ERC2981Upgradeable.sol";
/**
* @title LazySovereignNFT
* @dev This contract implements an ERC721 compliant NFT (Non-Fungible Token) with lazy minting.
*/
contract LazySovereignNFT is
OwnableUpgradeable,
ERC165Upgradeable,
ERC721Upgradeable,
ITokenCreator,
ERC721BurnableUpgradeable,
ERC2981Upgradeable
{
using SafeMathUpgradeable for uint256;
using StringsUpgradeable for uint256;
using CountersUpgradeable for CountersUpgradeable.Counter;
/////////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////////
struct MintConfig {
uint256 numberOfTokens;
string baseURI;
bool lockedMetadata;
}
/////////////////////////////////////////////////////////////////////////////
// Storage
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////
// Public
//////////////////////////////////////////////
// Disabled flag
bool public disabled;
// Maximum number of tokens that can be minted
uint256 public maxTokens;
//////////////////////////////////////////////
// Private
//////////////////////////////////////////////
// Mapping from token ID to approved address
mapping(uint256 => address) private tokenApprovals;
// Mapping from addresses that can mint outside of the owner
mapping(address => bool) private minterAddresses;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
// Counter to keep track of the current token id.
CountersUpgradeable.Counter private tokenIdCounter;
// Mint batches for batch minting
MintConfig private mintConfig;
/////////////////////////////////////////////////////////////////////////////
// Events
/////////////////////////////////////////////////////////////////////////////
// Emits when the contract is disabled.
event ContractDisabled(address indexed user);
// Emits when prepared for minting.
event PrepareMint(uint256 indexed numberOfTokens, string baseURI);
// Emits when metadata is locked.
event MetadataLocked(string baseURI);
// Emits when metadata is updated.
event MetadataUpdated(string baseURI);
// Emits when token URI is updated.
event TokenURIUpdated(uint256 indexed tokenId, string metadataUri);
/////////////////////////////////////////////////////////////////////////////
// Init
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Contract initialization function.
* @param _name The name of the NFT contract.
* @param _symbol The symbol of the NFT contract.
* @param _creator The address of the contract creator.
* @param _maxTokens The maximum number of tokens that can be minted.
*/
function init(
string calldata _name,
string calldata _symbol,
address _creator,
uint256 _maxTokens
) public initializer {
}
/////////////////////////////////////////////////////////////////////////////
// Modifiers
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Modifier to check if the contract is not disabled.
*/
modifier ifNotDisabled() {
}
/////////////////////////////////////////////////////////////////////////////
// Write Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Set a minter for the contract
* @param _minter address of the minter.
* @param _isMinter bool of whether the address is a minter.
*/
function setMinterApproval(
address _minter,
bool _isMinter
) public onlyOwner ifNotDisabled {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
*/
function prepareMint(
string calldata _baseURI,
uint256 _numberOfTokens
) public onlyOwner ifNotDisabled {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens, and assign a minter address.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
* @param _minter The address of the minter.
*/
function prepareMintWithMinter(
string calldata _baseURI,
uint256 _numberOfTokens,
address _minter
) public onlyOwner ifNotDisabled {
}
/**
* @dev Mint a new token to the specified receiver.
* @param _receiver The address of the token receiver.
* @return uint256 Token Id of the new token.
*/
function mintTo(
address _receiver
) external ifNotDisabled returns (uint256) {
}
/**
* @dev Delete a token with the given ID.
* @param _tokenId The ID of the token to delete.
*/
function deleteToken(uint256 _tokenId) public {
}
/**
* @dev Disable the contract, preventing further minting.
*/
function disableContract() public onlyOwner {
}
/**
* @dev Set the default royalty receiver address.
* @param _receiver The address of the default royalty receiver.
*/
function setDefaultRoyaltyReceiver(address _receiver) external onlyOwner {
}
/**
* @dev Set a specific royalty receiver address for a token.
* @param _receiver The address of the royalty receiver.
* @param _tokenId The ID of the token.
*/
function setRoyaltyReceiverForToken(
address _receiver,
uint256 _tokenId
) external onlyOwner {
}
/**
* @dev Update the base URI.
* @param _baseURI The new base URI.
*/
function updateBaseURI(string calldata _baseURI) external onlyOwner {
require(<FILL_ME>)
mintConfig.baseURI = _baseURI;
emit MetadataUpdated(_baseURI);
}
/**
* @dev Update the token metadata URI.
* @param _metadataUri The new metadata URI.
*/
function updateTokenURI(
uint256 _tokenId,
string calldata _metadataUri
) external onlyOwner {
}
/**
* @dev Lock the metadata to prevent further updates.
*/
function lockBaseURI() external onlyOwner {
}
/////////////////////////////////////////////////////////////////////////////
// Read Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Checks if the supplied address is approved for minting
* @param _address The address of the minter.
* @return bool, whether the address is approved for minting.
*/
function isApprovedMinter(address _address) public view returns (bool) {
}
/**
* @dev Get the address of the token creator for a given token ID.
* @param _tokenId The ID of the token.
* @return address of the token creator.
*/
function tokenCreator(
uint256 _tokenId
) public view override returns (address payable) {
}
/**
* @dev Get the current minting configuration.
* @return mintConfig the mint config.
*/
function getMintConfig() public view returns (MintConfig memory) {
}
/**
* @dev Get the token URI for a specific token. If a token has a set URI,
* it will return that, otherwise it will return the token URI computed from
* the base URI.
* @param _tokenId The ID of the token.
* @return The token's URI.
*/
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
/**
* @dev Get the total supply of tokens in existence.
* @return The total supply of tokens.
*/
function totalSupply() public view virtual returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(ERC165Upgradeable, ERC2981Upgradeable, ERC721Upgradeable)
returns (bool)
{
}
/////////////////////////////////////////////////////////////////////////////
// Internal Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Create a new token and assign it to the specified recipient.
* @param _to The address of the token recipient.
* @param _royaltyPercentage The royalty percentage for the token.
* @param _royaltyReceiver The address of the royalty receiver for the token.
* @return The ID of the newly created token.
*/
function _createToken(
address _to,
uint256 _royaltyPercentage,
address _royaltyReceiver
) internal returns (uint256) {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
*/
function _prepareMint(
string calldata _baseURI,
uint256 _numberOfTokens
) internal {
}
}
| !mintConfig.lockedMetadata,"updateBaseURI::metadata is locked" | 467,093 | !mintConfig.lockedMetadata |
"_prepareMint::can only prepare mint with 0 tokens" | // contracts/token/ERC721/sovereign/SovereignNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
import "openzeppelin-contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import "openzeppelin-contracts-upgradeable/token/ERC721/extensions/ERC721BurnableUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "openzeppelin-contracts-upgradeable/access/OwnableUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/CountersUpgradeable.sol";
import "openzeppelin-contracts-upgradeable/utils/math/SafeMathUpgradeable.sol";
import "../../../extensions/ITokenCreator.sol";
import "../../../extensions/ERC2981Upgradeable.sol";
/**
* @title LazySovereignNFT
* @dev This contract implements an ERC721 compliant NFT (Non-Fungible Token) with lazy minting.
*/
contract LazySovereignNFT is
OwnableUpgradeable,
ERC165Upgradeable,
ERC721Upgradeable,
ITokenCreator,
ERC721BurnableUpgradeable,
ERC2981Upgradeable
{
using SafeMathUpgradeable for uint256;
using StringsUpgradeable for uint256;
using CountersUpgradeable for CountersUpgradeable.Counter;
/////////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////////
struct MintConfig {
uint256 numberOfTokens;
string baseURI;
bool lockedMetadata;
}
/////////////////////////////////////////////////////////////////////////////
// Storage
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////
// Public
//////////////////////////////////////////////
// Disabled flag
bool public disabled;
// Maximum number of tokens that can be minted
uint256 public maxTokens;
//////////////////////////////////////////////
// Private
//////////////////////////////////////////////
// Mapping from token ID to approved address
mapping(uint256 => address) private tokenApprovals;
// Mapping from addresses that can mint outside of the owner
mapping(address => bool) private minterAddresses;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
// Counter to keep track of the current token id.
CountersUpgradeable.Counter private tokenIdCounter;
// Mint batches for batch minting
MintConfig private mintConfig;
/////////////////////////////////////////////////////////////////////////////
// Events
/////////////////////////////////////////////////////////////////////////////
// Emits when the contract is disabled.
event ContractDisabled(address indexed user);
// Emits when prepared for minting.
event PrepareMint(uint256 indexed numberOfTokens, string baseURI);
// Emits when metadata is locked.
event MetadataLocked(string baseURI);
// Emits when metadata is updated.
event MetadataUpdated(string baseURI);
// Emits when token URI is updated.
event TokenURIUpdated(uint256 indexed tokenId, string metadataUri);
/////////////////////////////////////////////////////////////////////////////
// Init
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Contract initialization function.
* @param _name The name of the NFT contract.
* @param _symbol The symbol of the NFT contract.
* @param _creator The address of the contract creator.
* @param _maxTokens The maximum number of tokens that can be minted.
*/
function init(
string calldata _name,
string calldata _symbol,
address _creator,
uint256 _maxTokens
) public initializer {
}
/////////////////////////////////////////////////////////////////////////////
// Modifiers
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Modifier to check if the contract is not disabled.
*/
modifier ifNotDisabled() {
}
/////////////////////////////////////////////////////////////////////////////
// Write Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Set a minter for the contract
* @param _minter address of the minter.
* @param _isMinter bool of whether the address is a minter.
*/
function setMinterApproval(
address _minter,
bool _isMinter
) public onlyOwner ifNotDisabled {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
*/
function prepareMint(
string calldata _baseURI,
uint256 _numberOfTokens
) public onlyOwner ifNotDisabled {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens, and assign a minter address.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
* @param _minter The address of the minter.
*/
function prepareMintWithMinter(
string calldata _baseURI,
uint256 _numberOfTokens,
address _minter
) public onlyOwner ifNotDisabled {
}
/**
* @dev Mint a new token to the specified receiver.
* @param _receiver The address of the token receiver.
* @return uint256 Token Id of the new token.
*/
function mintTo(
address _receiver
) external ifNotDisabled returns (uint256) {
}
/**
* @dev Delete a token with the given ID.
* @param _tokenId The ID of the token to delete.
*/
function deleteToken(uint256 _tokenId) public {
}
/**
* @dev Disable the contract, preventing further minting.
*/
function disableContract() public onlyOwner {
}
/**
* @dev Set the default royalty receiver address.
* @param _receiver The address of the default royalty receiver.
*/
function setDefaultRoyaltyReceiver(address _receiver) external onlyOwner {
}
/**
* @dev Set a specific royalty receiver address for a token.
* @param _receiver The address of the royalty receiver.
* @param _tokenId The ID of the token.
*/
function setRoyaltyReceiverForToken(
address _receiver,
uint256 _tokenId
) external onlyOwner {
}
/**
* @dev Update the base URI.
* @param _baseURI The new base URI.
*/
function updateBaseURI(string calldata _baseURI) external onlyOwner {
}
/**
* @dev Update the token metadata URI.
* @param _metadataUri The new metadata URI.
*/
function updateTokenURI(
uint256 _tokenId,
string calldata _metadataUri
) external onlyOwner {
}
/**
* @dev Lock the metadata to prevent further updates.
*/
function lockBaseURI() external onlyOwner {
}
/////////////////////////////////////////////////////////////////////////////
// Read Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Checks if the supplied address is approved for minting
* @param _address The address of the minter.
* @return bool, whether the address is approved for minting.
*/
function isApprovedMinter(address _address) public view returns (bool) {
}
/**
* @dev Get the address of the token creator for a given token ID.
* @param _tokenId The ID of the token.
* @return address of the token creator.
*/
function tokenCreator(
uint256 _tokenId
) public view override returns (address payable) {
}
/**
* @dev Get the current minting configuration.
* @return mintConfig the mint config.
*/
function getMintConfig() public view returns (MintConfig memory) {
}
/**
* @dev Get the token URI for a specific token. If a token has a set URI,
* it will return that, otherwise it will return the token URI computed from
* the base URI.
* @param _tokenId The ID of the token.
* @return The token's URI.
*/
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
/**
* @dev Get the total supply of tokens in existence.
* @return The total supply of tokens.
*/
function totalSupply() public view virtual returns (uint256) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(ERC165Upgradeable, ERC2981Upgradeable, ERC721Upgradeable)
returns (bool)
{
}
/////////////////////////////////////////////////////////////////////////////
// Internal Functions
/////////////////////////////////////////////////////////////////////////////
/**
* @dev Create a new token and assign it to the specified recipient.
* @param _to The address of the token recipient.
* @param _royaltyPercentage The royalty percentage for the token.
* @param _royaltyReceiver The address of the royalty receiver for the token.
* @return The ID of the newly created token.
*/
function _createToken(
address _to,
uint256 _royaltyPercentage,
address _royaltyReceiver
) internal returns (uint256) {
}
/**
* @dev Prepare a minting batch with a specified base URI and number of tokens.
* @param _baseURI The base URI for token metadata.
* @param _numberOfTokens The number of tokens to prepare for minting.
*/
function _prepareMint(
string calldata _baseURI,
uint256 _numberOfTokens
) internal {
require(
_numberOfTokens <= maxTokens,
"_prepareMint::exceeded maxTokens"
);
require(<FILL_ME>)
mintConfig = MintConfig(_numberOfTokens, _baseURI, false);
emit PrepareMint(_numberOfTokens, _baseURI);
}
}
| tokenIdCounter.current()==0,"_prepareMint::can only prepare mint with 0 tokens" | 467,093 | tokenIdCounter.current()==0 |
"Not sign by signer" | // $$\ $$$$$$\ $$$$$$\ $$\ $$\
// $$ | $$ ___$$\ $$$ __$$\ $$ |\__|
// $$\ $$\ $$\ $$$$$$\ $$$$$$$\ \_/ $$ | $$$$\ $$ |$$$$$$\$$$$\ $$$$$$\ $$$$$$$ |$$\ $$$$$$\
// $$ | $$ | $$ |$$ __$$\ $$ __$$\ $$$$$ / $$\$$\$$ |$$ _$$ _$$\ $$ __$$\ $$ __$$ |$$ | \____$$\
// $$ | $$ | $$ |$$$$$$$$ |$$ | $$ | \___$$\ $$ \$$$$ |$$ / $$ / $$ |$$$$$$$$ |$$ / $$ |$$ | $$$$$$$ |
// $$ | $$ | $$ |$$ ____|$$ | $$ |$$\ $$ | $$ |\$$$ |$$ | $$ | $$ |$$ ____|$$ | $$ |$$ |$$ __$$ |
// \$$$$$\$$$$ |\$$$$$$$\ $$$$$$$ |\$$$$$$ |$$\\$$$$$$ /$$ | $$ | $$ |\$$$$$$$\ \$$$$$$$ |$$ |\$$$$$$$ |
// \_____\____/ \_______|\_______/ \______/ \__|\______/ \__| \__| \__| \_______| \_______|\__| \_______|
pragma solidity ^0.8.9;
contract WeAreLand is AbstractERC1155Factory, ReentrancyGuard, VerifySign, CalScore{
mapping (uint256 => bool) public claimedWeareId;
uint256 public constant WeAreCalm = 1;
uint256 public constant WeAreRelax = 2;
uint256 public constant WeAreHappy = 3;
uint256 public constant WeAreRich = 4;
uint256 public constant WeAreFree = 5;
string public contractURi = "https://gateway.pinata.cloud/ipfs/QmbDDXaqGYS29ahymuLofioBzDDfoazwmmqzupT8TpEQDy";
string public uriPrefix = "ipfs://QmUdX9a4t2mLqSkoz73p332RiHGvmnfWtEuQxdTSiqaSkA/";
string public uriSuffix = ".json";
address public piplAddress = 0x6Cbf5aB650a7CCb12cf7a4c97E60600A989AcfE1;
address public weareAddress = 0x7b41874eFe38Ea0E4866307B7208D9C856745d31;
uint256 public requirePiplAmount = 4;
uint256 public requireWeAreAmount = 2;
uint256 public claimTokenAmount = 100000;
address public signerAddress = 0xA6e8318353B20660dD9EC9fDaD7361Ad350e917e;
constructor() ERC1155(uriPrefix) {
}
event claimed(address indexed _to, uint256 indexed _tokenId);
function claim(uint256[] calldata pipl_tokenId, uint256[] calldata weare_tokenId, uint256 _totalScore, uint8 v, bytes32 r, bytes32 s) public payable whenNotPaused{
PIPL piplContact = PIPL(piplAddress);
WeAre weareContact = WeAre(weareAddress);
//verify signature
require(<FILL_ME>)
require(pipl_tokenId.length == requirePiplAmount, "Please input a vaild amount of pipl tokenId");
require(weare_tokenId.length == requireWeAreAmount, "Please input a vaild amount of WeAre tokenId");
for (uint i = 0; i < requireWeAreAmount; i++){
require(weareContact.ownerOf(weare_tokenId[i]) == msg.sender, "You must be owner of the WeAre");
require(claimedWeareId[weare_tokenId[i]] == false, "Please use unclaimed WeAre for claim");
//mark down claimed WeAre
claimedWeareId[weare_tokenId[i]] = true;
}
for (uint i = 0; i < requirePiplAmount; i++){
//burn the token
require(piplContact.getApproved(pipl_tokenId[i]) == address(this) || piplContact.isApprovedForAll(msg.sender, address(this)) == true, "Please approve the token for claim");
piplContact.safeTransferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD , pipl_tokenId[i]);
}
//random
uint256 randomNumber = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender,block.difficulty)));
randomNumber = (randomNumber % 100) + 1;
uint256 landId = calculate(_totalScore, randomNumber);
_mint(msg.sender, landId, 1, "");
emit claimed(msg.sender, landId);
}
// For marketing etc.
function mintForAddress(uint256 _tokenId, uint256 _mintAmount, address _receiver) public onlyOwner {
}
function mintForAddressBatch(uint256[] memory _tokenId, uint256[] memory _mintAmount, address _receiver) public onlyOwner {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setSignerAddress(address _signerAddress) public onlyOwner {
}
function setContractURI(string memory _newContractURI) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setRequirePiplAmount(uint256 _requirePiplAmount) public onlyOwner {
}
function setRequireWeAreAmount(uint256 _requireWeAreAmount) public onlyOwner {
}
function setClaimTokenAmount(uint256 _claimTokenAmount) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| verifySig(pipl_tokenId,_totalScore,v,r,s)==signerAddress,"Not sign by signer" | 467,165 | verifySig(pipl_tokenId,_totalScore,v,r,s)==signerAddress |
"You must be owner of the WeAre" | // $$\ $$$$$$\ $$$$$$\ $$\ $$\
// $$ | $$ ___$$\ $$$ __$$\ $$ |\__|
// $$\ $$\ $$\ $$$$$$\ $$$$$$$\ \_/ $$ | $$$$\ $$ |$$$$$$\$$$$\ $$$$$$\ $$$$$$$ |$$\ $$$$$$\
// $$ | $$ | $$ |$$ __$$\ $$ __$$\ $$$$$ / $$\$$\$$ |$$ _$$ _$$\ $$ __$$\ $$ __$$ |$$ | \____$$\
// $$ | $$ | $$ |$$$$$$$$ |$$ | $$ | \___$$\ $$ \$$$$ |$$ / $$ / $$ |$$$$$$$$ |$$ / $$ |$$ | $$$$$$$ |
// $$ | $$ | $$ |$$ ____|$$ | $$ |$$\ $$ | $$ |\$$$ |$$ | $$ | $$ |$$ ____|$$ | $$ |$$ |$$ __$$ |
// \$$$$$\$$$$ |\$$$$$$$\ $$$$$$$ |\$$$$$$ |$$\\$$$$$$ /$$ | $$ | $$ |\$$$$$$$\ \$$$$$$$ |$$ |\$$$$$$$ |
// \_____\____/ \_______|\_______/ \______/ \__|\______/ \__| \__| \__| \_______| \_______|\__| \_______|
pragma solidity ^0.8.9;
contract WeAreLand is AbstractERC1155Factory, ReentrancyGuard, VerifySign, CalScore{
mapping (uint256 => bool) public claimedWeareId;
uint256 public constant WeAreCalm = 1;
uint256 public constant WeAreRelax = 2;
uint256 public constant WeAreHappy = 3;
uint256 public constant WeAreRich = 4;
uint256 public constant WeAreFree = 5;
string public contractURi = "https://gateway.pinata.cloud/ipfs/QmbDDXaqGYS29ahymuLofioBzDDfoazwmmqzupT8TpEQDy";
string public uriPrefix = "ipfs://QmUdX9a4t2mLqSkoz73p332RiHGvmnfWtEuQxdTSiqaSkA/";
string public uriSuffix = ".json";
address public piplAddress = 0x6Cbf5aB650a7CCb12cf7a4c97E60600A989AcfE1;
address public weareAddress = 0x7b41874eFe38Ea0E4866307B7208D9C856745d31;
uint256 public requirePiplAmount = 4;
uint256 public requireWeAreAmount = 2;
uint256 public claimTokenAmount = 100000;
address public signerAddress = 0xA6e8318353B20660dD9EC9fDaD7361Ad350e917e;
constructor() ERC1155(uriPrefix) {
}
event claimed(address indexed _to, uint256 indexed _tokenId);
function claim(uint256[] calldata pipl_tokenId, uint256[] calldata weare_tokenId, uint256 _totalScore, uint8 v, bytes32 r, bytes32 s) public payable whenNotPaused{
PIPL piplContact = PIPL(piplAddress);
WeAre weareContact = WeAre(weareAddress);
//verify signature
require(verifySig(pipl_tokenId, _totalScore, v, r, s) == signerAddress, "Not sign by signer");
require(pipl_tokenId.length == requirePiplAmount, "Please input a vaild amount of pipl tokenId");
require(weare_tokenId.length == requireWeAreAmount, "Please input a vaild amount of WeAre tokenId");
for (uint i = 0; i < requireWeAreAmount; i++){
require(<FILL_ME>)
require(claimedWeareId[weare_tokenId[i]] == false, "Please use unclaimed WeAre for claim");
//mark down claimed WeAre
claimedWeareId[weare_tokenId[i]] = true;
}
for (uint i = 0; i < requirePiplAmount; i++){
//burn the token
require(piplContact.getApproved(pipl_tokenId[i]) == address(this) || piplContact.isApprovedForAll(msg.sender, address(this)) == true, "Please approve the token for claim");
piplContact.safeTransferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD , pipl_tokenId[i]);
}
//random
uint256 randomNumber = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender,block.difficulty)));
randomNumber = (randomNumber % 100) + 1;
uint256 landId = calculate(_totalScore, randomNumber);
_mint(msg.sender, landId, 1, "");
emit claimed(msg.sender, landId);
}
// For marketing etc.
function mintForAddress(uint256 _tokenId, uint256 _mintAmount, address _receiver) public onlyOwner {
}
function mintForAddressBatch(uint256[] memory _tokenId, uint256[] memory _mintAmount, address _receiver) public onlyOwner {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setSignerAddress(address _signerAddress) public onlyOwner {
}
function setContractURI(string memory _newContractURI) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setRequirePiplAmount(uint256 _requirePiplAmount) public onlyOwner {
}
function setRequireWeAreAmount(uint256 _requireWeAreAmount) public onlyOwner {
}
function setClaimTokenAmount(uint256 _claimTokenAmount) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| weareContact.ownerOf(weare_tokenId[i])==msg.sender,"You must be owner of the WeAre" | 467,165 | weareContact.ownerOf(weare_tokenId[i])==msg.sender |
"Please use unclaimed WeAre for claim" | // $$\ $$$$$$\ $$$$$$\ $$\ $$\
// $$ | $$ ___$$\ $$$ __$$\ $$ |\__|
// $$\ $$\ $$\ $$$$$$\ $$$$$$$\ \_/ $$ | $$$$\ $$ |$$$$$$\$$$$\ $$$$$$\ $$$$$$$ |$$\ $$$$$$\
// $$ | $$ | $$ |$$ __$$\ $$ __$$\ $$$$$ / $$\$$\$$ |$$ _$$ _$$\ $$ __$$\ $$ __$$ |$$ | \____$$\
// $$ | $$ | $$ |$$$$$$$$ |$$ | $$ | \___$$\ $$ \$$$$ |$$ / $$ / $$ |$$$$$$$$ |$$ / $$ |$$ | $$$$$$$ |
// $$ | $$ | $$ |$$ ____|$$ | $$ |$$\ $$ | $$ |\$$$ |$$ | $$ | $$ |$$ ____|$$ | $$ |$$ |$$ __$$ |
// \$$$$$\$$$$ |\$$$$$$$\ $$$$$$$ |\$$$$$$ |$$\\$$$$$$ /$$ | $$ | $$ |\$$$$$$$\ \$$$$$$$ |$$ |\$$$$$$$ |
// \_____\____/ \_______|\_______/ \______/ \__|\______/ \__| \__| \__| \_______| \_______|\__| \_______|
pragma solidity ^0.8.9;
contract WeAreLand is AbstractERC1155Factory, ReentrancyGuard, VerifySign, CalScore{
mapping (uint256 => bool) public claimedWeareId;
uint256 public constant WeAreCalm = 1;
uint256 public constant WeAreRelax = 2;
uint256 public constant WeAreHappy = 3;
uint256 public constant WeAreRich = 4;
uint256 public constant WeAreFree = 5;
string public contractURi = "https://gateway.pinata.cloud/ipfs/QmbDDXaqGYS29ahymuLofioBzDDfoazwmmqzupT8TpEQDy";
string public uriPrefix = "ipfs://QmUdX9a4t2mLqSkoz73p332RiHGvmnfWtEuQxdTSiqaSkA/";
string public uriSuffix = ".json";
address public piplAddress = 0x6Cbf5aB650a7CCb12cf7a4c97E60600A989AcfE1;
address public weareAddress = 0x7b41874eFe38Ea0E4866307B7208D9C856745d31;
uint256 public requirePiplAmount = 4;
uint256 public requireWeAreAmount = 2;
uint256 public claimTokenAmount = 100000;
address public signerAddress = 0xA6e8318353B20660dD9EC9fDaD7361Ad350e917e;
constructor() ERC1155(uriPrefix) {
}
event claimed(address indexed _to, uint256 indexed _tokenId);
function claim(uint256[] calldata pipl_tokenId, uint256[] calldata weare_tokenId, uint256 _totalScore, uint8 v, bytes32 r, bytes32 s) public payable whenNotPaused{
PIPL piplContact = PIPL(piplAddress);
WeAre weareContact = WeAre(weareAddress);
//verify signature
require(verifySig(pipl_tokenId, _totalScore, v, r, s) == signerAddress, "Not sign by signer");
require(pipl_tokenId.length == requirePiplAmount, "Please input a vaild amount of pipl tokenId");
require(weare_tokenId.length == requireWeAreAmount, "Please input a vaild amount of WeAre tokenId");
for (uint i = 0; i < requireWeAreAmount; i++){
require(weareContact.ownerOf(weare_tokenId[i]) == msg.sender, "You must be owner of the WeAre");
require(<FILL_ME>)
//mark down claimed WeAre
claimedWeareId[weare_tokenId[i]] = true;
}
for (uint i = 0; i < requirePiplAmount; i++){
//burn the token
require(piplContact.getApproved(pipl_tokenId[i]) == address(this) || piplContact.isApprovedForAll(msg.sender, address(this)) == true, "Please approve the token for claim");
piplContact.safeTransferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD , pipl_tokenId[i]);
}
//random
uint256 randomNumber = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender,block.difficulty)));
randomNumber = (randomNumber % 100) + 1;
uint256 landId = calculate(_totalScore, randomNumber);
_mint(msg.sender, landId, 1, "");
emit claimed(msg.sender, landId);
}
// For marketing etc.
function mintForAddress(uint256 _tokenId, uint256 _mintAmount, address _receiver) public onlyOwner {
}
function mintForAddressBatch(uint256[] memory _tokenId, uint256[] memory _mintAmount, address _receiver) public onlyOwner {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setSignerAddress(address _signerAddress) public onlyOwner {
}
function setContractURI(string memory _newContractURI) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setRequirePiplAmount(uint256 _requirePiplAmount) public onlyOwner {
}
function setRequireWeAreAmount(uint256 _requireWeAreAmount) public onlyOwner {
}
function setClaimTokenAmount(uint256 _claimTokenAmount) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| claimedWeareId[weare_tokenId[i]]==false,"Please use unclaimed WeAre for claim" | 467,165 | claimedWeareId[weare_tokenId[i]]==false |
"Please approve the token for claim" | // $$\ $$$$$$\ $$$$$$\ $$\ $$\
// $$ | $$ ___$$\ $$$ __$$\ $$ |\__|
// $$\ $$\ $$\ $$$$$$\ $$$$$$$\ \_/ $$ | $$$$\ $$ |$$$$$$\$$$$\ $$$$$$\ $$$$$$$ |$$\ $$$$$$\
// $$ | $$ | $$ |$$ __$$\ $$ __$$\ $$$$$ / $$\$$\$$ |$$ _$$ _$$\ $$ __$$\ $$ __$$ |$$ | \____$$\
// $$ | $$ | $$ |$$$$$$$$ |$$ | $$ | \___$$\ $$ \$$$$ |$$ / $$ / $$ |$$$$$$$$ |$$ / $$ |$$ | $$$$$$$ |
// $$ | $$ | $$ |$$ ____|$$ | $$ |$$\ $$ | $$ |\$$$ |$$ | $$ | $$ |$$ ____|$$ | $$ |$$ |$$ __$$ |
// \$$$$$\$$$$ |\$$$$$$$\ $$$$$$$ |\$$$$$$ |$$\\$$$$$$ /$$ | $$ | $$ |\$$$$$$$\ \$$$$$$$ |$$ |\$$$$$$$ |
// \_____\____/ \_______|\_______/ \______/ \__|\______/ \__| \__| \__| \_______| \_______|\__| \_______|
pragma solidity ^0.8.9;
contract WeAreLand is AbstractERC1155Factory, ReentrancyGuard, VerifySign, CalScore{
mapping (uint256 => bool) public claimedWeareId;
uint256 public constant WeAreCalm = 1;
uint256 public constant WeAreRelax = 2;
uint256 public constant WeAreHappy = 3;
uint256 public constant WeAreRich = 4;
uint256 public constant WeAreFree = 5;
string public contractURi = "https://gateway.pinata.cloud/ipfs/QmbDDXaqGYS29ahymuLofioBzDDfoazwmmqzupT8TpEQDy";
string public uriPrefix = "ipfs://QmUdX9a4t2mLqSkoz73p332RiHGvmnfWtEuQxdTSiqaSkA/";
string public uriSuffix = ".json";
address public piplAddress = 0x6Cbf5aB650a7CCb12cf7a4c97E60600A989AcfE1;
address public weareAddress = 0x7b41874eFe38Ea0E4866307B7208D9C856745d31;
uint256 public requirePiplAmount = 4;
uint256 public requireWeAreAmount = 2;
uint256 public claimTokenAmount = 100000;
address public signerAddress = 0xA6e8318353B20660dD9EC9fDaD7361Ad350e917e;
constructor() ERC1155(uriPrefix) {
}
event claimed(address indexed _to, uint256 indexed _tokenId);
function claim(uint256[] calldata pipl_tokenId, uint256[] calldata weare_tokenId, uint256 _totalScore, uint8 v, bytes32 r, bytes32 s) public payable whenNotPaused{
PIPL piplContact = PIPL(piplAddress);
WeAre weareContact = WeAre(weareAddress);
//verify signature
require(verifySig(pipl_tokenId, _totalScore, v, r, s) == signerAddress, "Not sign by signer");
require(pipl_tokenId.length == requirePiplAmount, "Please input a vaild amount of pipl tokenId");
require(weare_tokenId.length == requireWeAreAmount, "Please input a vaild amount of WeAre tokenId");
for (uint i = 0; i < requireWeAreAmount; i++){
require(weareContact.ownerOf(weare_tokenId[i]) == msg.sender, "You must be owner of the WeAre");
require(claimedWeareId[weare_tokenId[i]] == false, "Please use unclaimed WeAre for claim");
//mark down claimed WeAre
claimedWeareId[weare_tokenId[i]] = true;
}
for (uint i = 0; i < requirePiplAmount; i++){
//burn the token
require(<FILL_ME>)
piplContact.safeTransferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD , pipl_tokenId[i]);
}
//random
uint256 randomNumber = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender,block.difficulty)));
randomNumber = (randomNumber % 100) + 1;
uint256 landId = calculate(_totalScore, randomNumber);
_mint(msg.sender, landId, 1, "");
emit claimed(msg.sender, landId);
}
// For marketing etc.
function mintForAddress(uint256 _tokenId, uint256 _mintAmount, address _receiver) public onlyOwner {
}
function mintForAddressBatch(uint256[] memory _tokenId, uint256[] memory _mintAmount, address _receiver) public onlyOwner {
}
function uri(uint256 _tokenId) public view virtual override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
function setSignerAddress(address _signerAddress) public onlyOwner {
}
function setContractURI(string memory _newContractURI) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setRequirePiplAmount(uint256 _requirePiplAmount) public onlyOwner {
}
function setRequireWeAreAmount(uint256 _requireWeAreAmount) public onlyOwner {
}
function setClaimTokenAmount(uint256 _claimTokenAmount) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| piplContact.getApproved(pipl_tokenId[i])==address(this)||piplContact.isApprovedForAll(msg.sender,address(this))==true,"Please approve the token for claim" | 467,165 | piplContact.getApproved(pipl_tokenId[i])==address(this)||piplContact.isApprovedForAll(msg.sender,address(this))==true |
"Sold out." | pragma solidity ^0.8.4;
contract Notaland is Ownable, ERC721A, ReentrancyGuard {
struct NotalandConfig {
uint256 price;
uint256 maxMint;
uint256 maxSupply;
}
NotalandConfig public notalandConfig;
constructor() ERC721A("Notaland", "NAL") {
}
event TokenTriggered(uint256 tokenId);
/// first 333 for free
uint256 public freeRemain = 333;
mapping(address => bool) public freeMinted;
bool public triggerEnabled = false;
mapping(uint256 => uint256) public seeds;
mapping(uint256 => uint256) public itemTimestamp;
mapping(uint256 => bool) public itemStatus;
uint256 private nalMinted = 0;
uint256[] public nalRange = [0,0,0,0,0,0,0,0,0,0,0,0,0];
uint256[] private nalPatterns = [0,0,0,0,0,0,0,1,2,3,4,4,4,5,5,5,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,10,10,10,10,10,10,10,11,11,11,11,11,11,11,12,12];
string[] private nalTypes = ["Coin", "River area", "Ground area", "Snow area", "Mystery bag", "Food", "Grass brick", "Sand brick", "Rock brick", "Pet", "Tool", "Weapon", "Character"];
string[] private nalImages = [
"QmQccRFCSFuG6wYx53MwczGgfWwzAQvoh5RaXJpWzgxnhC",
"QmQL3ykcbEs5k25v94vc7X8yNHmfPSJxWzkCzzYLkUB9wp",
"QmWj7fete9ejBVkoh87j2aUfaeK9fqYxWCttvpCEzXtnPa",
"QmVEU8qgW7q4XcGC3njXS8VCtpxwXZqpLHfjc6C9pFsgme",
"QmTvFC8tGdS4NzbqKt8EkQA8E4qq6LAxpW2gPfYXhoCJiK",
"QmcwvptV51e1K17PzxjR5kBSkkjeo2sQxqgSv5XaQ8a6NB",
"QmSi17sUPngTMh9qcp3K3h1tS8Cbms7a2czUgmUmHkJAXb",
"QmPcL7sX1gej5Z7bTb3yCfPW4JKEmjFcUo2uAGhYVwiZCz",
"Qma4TmZCEjJrjdbedWDYTXXWFo2QTaXsMEXqMHNAjvDuST",
"QmUwi1FLatJGmq9nRN4AZc3JTgndWAXXfkX4BMSXn8cKYL",
"QmYGA98Tq9XEjTYXGSWMk4qV6WciQ9AfsycxPdvz141jLY",
"QmYfArBndcHYKLrBdKr88qHn8CgK71XXuWTs8sJVRmWhiH",
"QmU17dKbZueK7TVdwggtYyphmQKt9R69uVXcoQ8wqUs44P"
];
function getNAL(uint256 quantity) external payable {
NotalandConfig memory config = notalandConfig;
uint256 price = uint256(config.price);
uint256 maxMint = uint256(config.maxMint);
uint256 buyed = numberMinted(msg.sender);
require(<FILL_ME>)
require(
buyed + quantity <= maxMint,
"Exceed maxmium mint."
);
if (freeRemain > 0 && !freeMinted[msg.sender]) {
require(!freeMinted[msg.sender], "No more free mint for this wallet.");
require(
quantity == 1,
"Max to 1 with free mint."
);
_getFreeNAL();
} else {
require(
quantity * price <= msg.value,
"No enough eth."
);
_getNAL(quantity);
}
}
function _getFreeNAL() private {
}
function _getNAL(uint256 quantity) private {
}
function reserve(uint256 quantity) external onlyOwner {
}
function getMaxSupply() private view returns (uint256) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxMint(uint256 _amount) external onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function numberMinted(address _addr) public view returns(uint256){
}
function _startTokenId() override internal pure virtual returns (uint256) {
}
/// tokensOfOwner - source: https://github.com/chiru-labs/ERC721A/blob/main/contracts/extensions/ERC721AQueryable.sol
function tokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
}
///----------------------///
/// ^ Base ^
///----------------------///
///----------------------///
/// v Not a land v
///----------------------///
function _getPatternId(uint256 tokenId) private view returns (uint256) {
}
function _setSeed(uint256 tokenId) private {
}
function _getAttr(uint256 patternId, uint256 tokenId) private view returns (string memory) {
}
function _getImage(uint256 patternId) private view returns (string memory) {
}
function _tokenURI(uint256 tokenId) private view returns (string memory) {
}
function tokenURI(uint256 tokenId) override (ERC721A) public view returns (string memory) {
}
///----------------------///
/// NAL - Tokens owner
///----------------------///
// Unpack a mystery bag, just refreshing metadata, only cost gas and you may get mystery bag again !
function unpack(uint256 tokenId) external {
}
function triggerToken(uint256 tokenId) external {
}
function _setItemTimestamp(uint256 tokenId) private {
}
///----------------------///
/// NAL - Admin
///----------------------///
// Use this function for special cases, such as stolen.
function setItemStatus(uint256 tokenId, bool status) external onlyOwner {
}
function setNalRange(uint256[] calldata _range) external onlyOwner {
}
function flipTriggerStatus() external onlyOwner {
}
}
| totalSupply()+quantity<=getMaxSupply(),"Sold out." | 467,375 | totalSupply()+quantity<=getMaxSupply() |
"Exceed maxmium mint." | pragma solidity ^0.8.4;
contract Notaland is Ownable, ERC721A, ReentrancyGuard {
struct NotalandConfig {
uint256 price;
uint256 maxMint;
uint256 maxSupply;
}
NotalandConfig public notalandConfig;
constructor() ERC721A("Notaland", "NAL") {
}
event TokenTriggered(uint256 tokenId);
/// first 333 for free
uint256 public freeRemain = 333;
mapping(address => bool) public freeMinted;
bool public triggerEnabled = false;
mapping(uint256 => uint256) public seeds;
mapping(uint256 => uint256) public itemTimestamp;
mapping(uint256 => bool) public itemStatus;
uint256 private nalMinted = 0;
uint256[] public nalRange = [0,0,0,0,0,0,0,0,0,0,0,0,0];
uint256[] private nalPatterns = [0,0,0,0,0,0,0,1,2,3,4,4,4,5,5,5,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,10,10,10,10,10,10,10,11,11,11,11,11,11,11,12,12];
string[] private nalTypes = ["Coin", "River area", "Ground area", "Snow area", "Mystery bag", "Food", "Grass brick", "Sand brick", "Rock brick", "Pet", "Tool", "Weapon", "Character"];
string[] private nalImages = [
"QmQccRFCSFuG6wYx53MwczGgfWwzAQvoh5RaXJpWzgxnhC",
"QmQL3ykcbEs5k25v94vc7X8yNHmfPSJxWzkCzzYLkUB9wp",
"QmWj7fete9ejBVkoh87j2aUfaeK9fqYxWCttvpCEzXtnPa",
"QmVEU8qgW7q4XcGC3njXS8VCtpxwXZqpLHfjc6C9pFsgme",
"QmTvFC8tGdS4NzbqKt8EkQA8E4qq6LAxpW2gPfYXhoCJiK",
"QmcwvptV51e1K17PzxjR5kBSkkjeo2sQxqgSv5XaQ8a6NB",
"QmSi17sUPngTMh9qcp3K3h1tS8Cbms7a2czUgmUmHkJAXb",
"QmPcL7sX1gej5Z7bTb3yCfPW4JKEmjFcUo2uAGhYVwiZCz",
"Qma4TmZCEjJrjdbedWDYTXXWFo2QTaXsMEXqMHNAjvDuST",
"QmUwi1FLatJGmq9nRN4AZc3JTgndWAXXfkX4BMSXn8cKYL",
"QmYGA98Tq9XEjTYXGSWMk4qV6WciQ9AfsycxPdvz141jLY",
"QmYfArBndcHYKLrBdKr88qHn8CgK71XXuWTs8sJVRmWhiH",
"QmU17dKbZueK7TVdwggtYyphmQKt9R69uVXcoQ8wqUs44P"
];
function getNAL(uint256 quantity) external payable {
NotalandConfig memory config = notalandConfig;
uint256 price = uint256(config.price);
uint256 maxMint = uint256(config.maxMint);
uint256 buyed = numberMinted(msg.sender);
require(
totalSupply() + quantity <= getMaxSupply(),
"Sold out."
);
require(<FILL_ME>)
if (freeRemain > 0 && !freeMinted[msg.sender]) {
require(!freeMinted[msg.sender], "No more free mint for this wallet.");
require(
quantity == 1,
"Max to 1 with free mint."
);
_getFreeNAL();
} else {
require(
quantity * price <= msg.value,
"No enough eth."
);
_getNAL(quantity);
}
}
function _getFreeNAL() private {
}
function _getNAL(uint256 quantity) private {
}
function reserve(uint256 quantity) external onlyOwner {
}
function getMaxSupply() private view returns (uint256) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxMint(uint256 _amount) external onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function numberMinted(address _addr) public view returns(uint256){
}
function _startTokenId() override internal pure virtual returns (uint256) {
}
/// tokensOfOwner - source: https://github.com/chiru-labs/ERC721A/blob/main/contracts/extensions/ERC721AQueryable.sol
function tokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
}
///----------------------///
/// ^ Base ^
///----------------------///
///----------------------///
/// v Not a land v
///----------------------///
function _getPatternId(uint256 tokenId) private view returns (uint256) {
}
function _setSeed(uint256 tokenId) private {
}
function _getAttr(uint256 patternId, uint256 tokenId) private view returns (string memory) {
}
function _getImage(uint256 patternId) private view returns (string memory) {
}
function _tokenURI(uint256 tokenId) private view returns (string memory) {
}
function tokenURI(uint256 tokenId) override (ERC721A) public view returns (string memory) {
}
///----------------------///
/// NAL - Tokens owner
///----------------------///
// Unpack a mystery bag, just refreshing metadata, only cost gas and you may get mystery bag again !
function unpack(uint256 tokenId) external {
}
function triggerToken(uint256 tokenId) external {
}
function _setItemTimestamp(uint256 tokenId) private {
}
///----------------------///
/// NAL - Admin
///----------------------///
// Use this function for special cases, such as stolen.
function setItemStatus(uint256 tokenId, bool status) external onlyOwner {
}
function setNalRange(uint256[] calldata _range) external onlyOwner {
}
function flipTriggerStatus() external onlyOwner {
}
}
| buyed+quantity<=maxMint,"Exceed maxmium mint." | 467,375 | buyed+quantity<=maxMint |
"This token is unavailable" | pragma solidity ^0.8.4;
contract Notaland is Ownable, ERC721A, ReentrancyGuard {
struct NotalandConfig {
uint256 price;
uint256 maxMint;
uint256 maxSupply;
}
NotalandConfig public notalandConfig;
constructor() ERC721A("Notaland", "NAL") {
}
event TokenTriggered(uint256 tokenId);
/// first 333 for free
uint256 public freeRemain = 333;
mapping(address => bool) public freeMinted;
bool public triggerEnabled = false;
mapping(uint256 => uint256) public seeds;
mapping(uint256 => uint256) public itemTimestamp;
mapping(uint256 => bool) public itemStatus;
uint256 private nalMinted = 0;
uint256[] public nalRange = [0,0,0,0,0,0,0,0,0,0,0,0,0];
uint256[] private nalPatterns = [0,0,0,0,0,0,0,1,2,3,4,4,4,5,5,5,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,10,10,10,10,10,10,10,11,11,11,11,11,11,11,12,12];
string[] private nalTypes = ["Coin", "River area", "Ground area", "Snow area", "Mystery bag", "Food", "Grass brick", "Sand brick", "Rock brick", "Pet", "Tool", "Weapon", "Character"];
string[] private nalImages = [
"QmQccRFCSFuG6wYx53MwczGgfWwzAQvoh5RaXJpWzgxnhC",
"QmQL3ykcbEs5k25v94vc7X8yNHmfPSJxWzkCzzYLkUB9wp",
"QmWj7fete9ejBVkoh87j2aUfaeK9fqYxWCttvpCEzXtnPa",
"QmVEU8qgW7q4XcGC3njXS8VCtpxwXZqpLHfjc6C9pFsgme",
"QmTvFC8tGdS4NzbqKt8EkQA8E4qq6LAxpW2gPfYXhoCJiK",
"QmcwvptV51e1K17PzxjR5kBSkkjeo2sQxqgSv5XaQ8a6NB",
"QmSi17sUPngTMh9qcp3K3h1tS8Cbms7a2czUgmUmHkJAXb",
"QmPcL7sX1gej5Z7bTb3yCfPW4JKEmjFcUo2uAGhYVwiZCz",
"Qma4TmZCEjJrjdbedWDYTXXWFo2QTaXsMEXqMHNAjvDuST",
"QmUwi1FLatJGmq9nRN4AZc3JTgndWAXXfkX4BMSXn8cKYL",
"QmYGA98Tq9XEjTYXGSWMk4qV6WciQ9AfsycxPdvz141jLY",
"QmYfArBndcHYKLrBdKr88qHn8CgK71XXuWTs8sJVRmWhiH",
"QmU17dKbZueK7TVdwggtYyphmQKt9R69uVXcoQ8wqUs44P"
];
function getNAL(uint256 quantity) external payable {
}
function _getFreeNAL() private {
}
function _getNAL(uint256 quantity) private {
}
function reserve(uint256 quantity) external onlyOwner {
}
function getMaxSupply() private view returns (uint256) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxMint(uint256 _amount) external onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function numberMinted(address _addr) public view returns(uint256){
}
function _startTokenId() override internal pure virtual returns (uint256) {
}
/// tokensOfOwner - source: https://github.com/chiru-labs/ERC721A/blob/main/contracts/extensions/ERC721AQueryable.sol
function tokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
}
///----------------------///
/// ^ Base ^
///----------------------///
///----------------------///
/// v Not a land v
///----------------------///
function _getPatternId(uint256 tokenId) private view returns (uint256) {
}
function _setSeed(uint256 tokenId) private {
}
function _getAttr(uint256 patternId, uint256 tokenId) private view returns (string memory) {
}
function _getImage(uint256 patternId) private view returns (string memory) {
}
function _tokenURI(uint256 tokenId) private view returns (string memory) {
}
function tokenURI(uint256 tokenId) override (ERC721A) public view returns (string memory) {
}
///----------------------///
/// NAL - Tokens owner
///----------------------///
// Unpack a mystery bag, just refreshing metadata, only cost gas and you may get mystery bag again !
function unpack(uint256 tokenId) external {
}
function triggerToken(uint256 tokenId) external {
require(ownerOf(tokenId) == msg.sender, "Not token owner");
require(triggerEnabled, "Not in trigger stage");
require(<FILL_ME>)
uint256 patternId = _getPatternId(tokenId);
require(block.timestamp - itemTimestamp[tokenId] > nalRange[patternId], "On cooldown");
_setItemTimestamp(tokenId);
emit TokenTriggered(tokenId);
}
function _setItemTimestamp(uint256 tokenId) private {
}
///----------------------///
/// NAL - Admin
///----------------------///
// Use this function for special cases, such as stolen.
function setItemStatus(uint256 tokenId, bool status) external onlyOwner {
}
function setNalRange(uint256[] calldata _range) external onlyOwner {
}
function flipTriggerStatus() external onlyOwner {
}
}
| itemStatus[tokenId],"This token is unavailable" | 467,375 | itemStatus[tokenId] |
"On cooldown" | pragma solidity ^0.8.4;
contract Notaland is Ownable, ERC721A, ReentrancyGuard {
struct NotalandConfig {
uint256 price;
uint256 maxMint;
uint256 maxSupply;
}
NotalandConfig public notalandConfig;
constructor() ERC721A("Notaland", "NAL") {
}
event TokenTriggered(uint256 tokenId);
/// first 333 for free
uint256 public freeRemain = 333;
mapping(address => bool) public freeMinted;
bool public triggerEnabled = false;
mapping(uint256 => uint256) public seeds;
mapping(uint256 => uint256) public itemTimestamp;
mapping(uint256 => bool) public itemStatus;
uint256 private nalMinted = 0;
uint256[] public nalRange = [0,0,0,0,0,0,0,0,0,0,0,0,0];
uint256[] private nalPatterns = [0,0,0,0,0,0,0,1,2,3,4,4,4,5,5,5,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,10,10,10,10,10,10,10,11,11,11,11,11,11,11,12,12];
string[] private nalTypes = ["Coin", "River area", "Ground area", "Snow area", "Mystery bag", "Food", "Grass brick", "Sand brick", "Rock brick", "Pet", "Tool", "Weapon", "Character"];
string[] private nalImages = [
"QmQccRFCSFuG6wYx53MwczGgfWwzAQvoh5RaXJpWzgxnhC",
"QmQL3ykcbEs5k25v94vc7X8yNHmfPSJxWzkCzzYLkUB9wp",
"QmWj7fete9ejBVkoh87j2aUfaeK9fqYxWCttvpCEzXtnPa",
"QmVEU8qgW7q4XcGC3njXS8VCtpxwXZqpLHfjc6C9pFsgme",
"QmTvFC8tGdS4NzbqKt8EkQA8E4qq6LAxpW2gPfYXhoCJiK",
"QmcwvptV51e1K17PzxjR5kBSkkjeo2sQxqgSv5XaQ8a6NB",
"QmSi17sUPngTMh9qcp3K3h1tS8Cbms7a2czUgmUmHkJAXb",
"QmPcL7sX1gej5Z7bTb3yCfPW4JKEmjFcUo2uAGhYVwiZCz",
"Qma4TmZCEjJrjdbedWDYTXXWFo2QTaXsMEXqMHNAjvDuST",
"QmUwi1FLatJGmq9nRN4AZc3JTgndWAXXfkX4BMSXn8cKYL",
"QmYGA98Tq9XEjTYXGSWMk4qV6WciQ9AfsycxPdvz141jLY",
"QmYfArBndcHYKLrBdKr88qHn8CgK71XXuWTs8sJVRmWhiH",
"QmU17dKbZueK7TVdwggtYyphmQKt9R69uVXcoQ8wqUs44P"
];
function getNAL(uint256 quantity) external payable {
}
function _getFreeNAL() private {
}
function _getNAL(uint256 quantity) private {
}
function reserve(uint256 quantity) external onlyOwner {
}
function getMaxSupply() private view returns (uint256) {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMaxMint(uint256 _amount) external onlyOwner {
}
function withdraw() external onlyOwner nonReentrant {
}
function numberMinted(address _addr) public view returns(uint256){
}
function _startTokenId() override internal pure virtual returns (uint256) {
}
/// tokensOfOwner - source: https://github.com/chiru-labs/ERC721A/blob/main/contracts/extensions/ERC721AQueryable.sol
function tokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
}
///----------------------///
/// ^ Base ^
///----------------------///
///----------------------///
/// v Not a land v
///----------------------///
function _getPatternId(uint256 tokenId) private view returns (uint256) {
}
function _setSeed(uint256 tokenId) private {
}
function _getAttr(uint256 patternId, uint256 tokenId) private view returns (string memory) {
}
function _getImage(uint256 patternId) private view returns (string memory) {
}
function _tokenURI(uint256 tokenId) private view returns (string memory) {
}
function tokenURI(uint256 tokenId) override (ERC721A) public view returns (string memory) {
}
///----------------------///
/// NAL - Tokens owner
///----------------------///
// Unpack a mystery bag, just refreshing metadata, only cost gas and you may get mystery bag again !
function unpack(uint256 tokenId) external {
}
function triggerToken(uint256 tokenId) external {
require(ownerOf(tokenId) == msg.sender, "Not token owner");
require(triggerEnabled, "Not in trigger stage");
require(itemStatus[tokenId], "This token is unavailable");
uint256 patternId = _getPatternId(tokenId);
require(<FILL_ME>)
_setItemTimestamp(tokenId);
emit TokenTriggered(tokenId);
}
function _setItemTimestamp(uint256 tokenId) private {
}
///----------------------///
/// NAL - Admin
///----------------------///
// Use this function for special cases, such as stolen.
function setItemStatus(uint256 tokenId, bool status) external onlyOwner {
}
function setNalRange(uint256[] calldata _range) external onlyOwner {
}
function flipTriggerStatus() external onlyOwner {
}
}
| block.timestamp-itemTimestamp[tokenId]>nalRange[patternId],"On cooldown" | 467,375 | block.timestamp-itemTimestamp[tokenId]>nalRange[patternId] |
"ONLY_SS_CALLABLE" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../interfaces/IFlashloanReceiver.sol";
import "../interfaces/IBalancer.sol";
import "../interfaces/IETHLeverage.sol";
import "../../utils/TransferHelper.sol";
contract BalancerReceiver is Ownable, IFlashloanReceiver {
using SafeMath for uint256;
// Balancer V2 Vault
address public balancer;
// Balancer Fee Pool
address public balancerFee;
// Substrategy address
address public subStrategy;
// Fee Decimal
uint256 public constant feeDecimal = 1e18;
// Fee Magnifier
uint256 public constant magnifier = 1e4;
// Registered balancer caller
mapping(address => bool) public balancerCaller;
// Flash loan state
bool private isLoan;
constructor(address _balancer, address _balancerFee, address _subStrategy) {
}
receive() external payable {}
modifier loanProcess() {
}
modifier onlyStrategy() {
require(<FILL_ME>)
_;
}
function getFee() external view override returns (uint256 fee) {
}
function flashLoan(
address token,
uint256 amount
) external override loanProcess onlyStrategy {
}
function receiveFlashLoan(
IERC20[] memory tokens,
uint256[] memory amounts,
uint256[] memory feeAmounts,
bytes memory userData
) public payable {
}
}
| _msgSender()==subStrategy,"ONLY_SS_CALLABLE" | 467,385 | _msgSender()==subStrategy |
"INSUFFICIENT_REFUND" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../interfaces/IFlashloanReceiver.sol";
import "../interfaces/IBalancer.sol";
import "../interfaces/IETHLeverage.sol";
import "../../utils/TransferHelper.sol";
contract BalancerReceiver is Ownable, IFlashloanReceiver {
using SafeMath for uint256;
// Balancer V2 Vault
address public balancer;
// Balancer Fee Pool
address public balancerFee;
// Substrategy address
address public subStrategy;
// Fee Decimal
uint256 public constant feeDecimal = 1e18;
// Fee Magnifier
uint256 public constant magnifier = 1e4;
// Registered balancer caller
mapping(address => bool) public balancerCaller;
// Flash loan state
bool private isLoan;
constructor(address _balancer, address _balancerFee, address _subStrategy) {
}
receive() external payable {}
modifier loanProcess() {
}
modifier onlyStrategy() {
}
function getFee() external view override returns (uint256 fee) {
}
function flashLoan(
address token,
uint256 amount
) external override loanProcess onlyStrategy {
}
function receiveFlashLoan(
IERC20[] memory tokens,
uint256[] memory amounts,
uint256[] memory feeAmounts,
bytes memory userData
) public payable {
require(msg.sender == balancer, "ONLY_FLASHLOAN_VAULT");
require(isLoan, "NOT_LOAN_REQUESTED");
IERC20 token = tokens[0];
uint256 loanAmt = amounts[0];
uint256 feeAmt = feeAmounts[0];
// Transfer Loan Token to ETH Leverage SS
TransferHelper.safeTransfer(address(token), subStrategy, loanAmt);
// Call Loan Fallback function in SS
IETHLeverage(subStrategy).loanFallback(loanAmt, feeAmt);
// Pay back flash loan
require(<FILL_ME>)
TransferHelper.safeTransfer(address(token), balancer, loanAmt + feeAmt);
}
}
| token.balanceOf(address(this))>=loanAmt+feeAmt,"INSUFFICIENT_REFUND" | 467,385 | token.balanceOf(address(this))>=loanAmt+feeAmt |
"10:url" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
*Error codes following the convention:
* 10: invalid value
* 20: not allowed
* 30: not enough founds
* 40: contract error
*
* A short description or parameter name must follow the code. Some of these short messages
* can be standardized, but many of them will be project dependant
* For example
* 10:open expands to: Contract not open
* 20:wallet expands to: Wallet not allowed to
* 30:token expands to: Not enough token amounts
* 40:external expands to: Unable to access external contract
*/
contract NPS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply;
uint256 public mintPrice;
uint256 public mintMax;
uint256 public holdMax;
address public signer;
bool public open;
string public baseURI;
uint256 public earnings;
address public gateway;
uint256 public maxFreebies;
uint256 public freebieCount;
mapping(uint256 => string) private _tokenURIs;
mapping(address => uint256) public freebies;
mapping(uint256 => bool) public freeTokens;
event Received(address, uint256);
event WithdrawalSuccess(uint256 amount);
struct SettingsStruct {
string name;
string symbol;
uint256 maxSupply;
uint256 mintPrice;
uint256 mintMax;
uint256 holdMax;
address signer;
bool open;
string baseURI;
uint256 earnings;
address gateway;
uint256 totalMinted;
uint256 totalBurned;
uint256 totalSupply;
uint256 maxFreebies;
uint256 freebieCount;
}
constructor(
string memory _name,
string memory _symbol,
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax,
address _signer
) ERC721A(_name, _symbol) {
}
receive() external payable {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function exists(uint256 id) public view returns (bool) {
}
function setBaseURI(string memory newURI) external onlyOwner {
require(<FILL_ME>)
baseURI = newURI;
}
function setGateway(address _gateway) external onlyOwner {
}
function setTokenURI(uint256 id, string memory newURI) external onlyOwner {
}
function setMaxSupply(uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function setSigner(address _signer) external onlyOwner {
}
function setOpen(bool _open) external onlyOwner {
}
function setMintPrice(uint256 price) public payable onlyOwner nonReentrant {
}
function setMintMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function setHoldMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function airdrop(address receiver, uint256 amount)
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mint(uint256 quantity) public payable nonReentrant {
}
function mintFreebie(bytes memory signature) public nonReentrant {
}
function mintCrossMint(uint256 quantity, address _to)
public
payable
nonReentrant
{
}
function _buy(address to, uint256 quantity) internal {
}
function burn(uint256 tokenId, bool approvalCheck)
public
payable
nonReentrant
{
}
function withdrawByOwner(address _address, uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function _verify(bytes memory signature) internal view returns (bool) {
}
function _verifyHashSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function setMultiple(
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax
) external onlyOwner {
}
function getSettings() public view returns (SettingsStruct memory) {
}
}
| bytes(newURI).length>0,"10:url" | 467,446 | bytes(newURI).length>0 |
"20:holdMax" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
*Error codes following the convention:
* 10: invalid value
* 20: not allowed
* 30: not enough founds
* 40: contract error
*
* A short description or parameter name must follow the code. Some of these short messages
* can be standardized, but many of them will be project dependant
* For example
* 10:open expands to: Contract not open
* 20:wallet expands to: Wallet not allowed to
* 30:token expands to: Not enough token amounts
* 40:external expands to: Unable to access external contract
*/
contract NPS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply;
uint256 public mintPrice;
uint256 public mintMax;
uint256 public holdMax;
address public signer;
bool public open;
string public baseURI;
uint256 public earnings;
address public gateway;
uint256 public maxFreebies;
uint256 public freebieCount;
mapping(uint256 => string) private _tokenURIs;
mapping(address => uint256) public freebies;
mapping(uint256 => bool) public freeTokens;
event Received(address, uint256);
event WithdrawalSuccess(uint256 amount);
struct SettingsStruct {
string name;
string symbol;
uint256 maxSupply;
uint256 mintPrice;
uint256 mintMax;
uint256 holdMax;
address signer;
bool open;
string baseURI;
uint256 earnings;
address gateway;
uint256 totalMinted;
uint256 totalBurned;
uint256 totalSupply;
uint256 maxFreebies;
uint256 freebieCount;
}
constructor(
string memory _name,
string memory _symbol,
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax,
address _signer
) ERC721A(_name, _symbol) {
}
receive() external payable {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function exists(uint256 id) public view returns (bool) {
}
function setBaseURI(string memory newURI) external onlyOwner {
}
function setGateway(address _gateway) external onlyOwner {
}
function setTokenURI(uint256 id, string memory newURI) external onlyOwner {
}
function setMaxSupply(uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function setSigner(address _signer) external onlyOwner {
}
function setOpen(bool _open) external onlyOwner {
}
function setMintPrice(uint256 price) public payable onlyOwner nonReentrant {
}
function setMintMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function setHoldMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function airdrop(address receiver, uint256 amount)
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mint(uint256 quantity) public payable nonReentrant {
require(open, "20:!open");
require(quantity > 0, "10:quantity");
require(quantity <= mintMax, "20:mintMax");
require(maxSupply >= _totalMinted() + quantity, "20:maxSupply");
require(<FILL_ME>)
require(msg.value >= mintPrice * quantity, "30:amount");
// Check for freebie only after validating the request and checking the quantity is not zero
_buy(msg.sender, quantity);
earnings += quantity * mintPrice;
}
function mintFreebie(bytes memory signature) public nonReentrant {
}
function mintCrossMint(uint256 quantity, address _to)
public
payable
nonReentrant
{
}
function _buy(address to, uint256 quantity) internal {
}
function burn(uint256 tokenId, bool approvalCheck)
public
payable
nonReentrant
{
}
function withdrawByOwner(address _address, uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function _verify(bytes memory signature) internal view returns (bool) {
}
function _verifyHashSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function setMultiple(
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax
) external onlyOwner {
}
function getSettings() public view returns (SettingsStruct memory) {
}
}
| _numberMinted(msg.sender)+quantity<=holdMax,"20:holdMax" | 467,446 | _numberMinted(msg.sender)+quantity<=holdMax |
"20:holdMax" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
*Error codes following the convention:
* 10: invalid value
* 20: not allowed
* 30: not enough founds
* 40: contract error
*
* A short description or parameter name must follow the code. Some of these short messages
* can be standardized, but many of them will be project dependant
* For example
* 10:open expands to: Contract not open
* 20:wallet expands to: Wallet not allowed to
* 30:token expands to: Not enough token amounts
* 40:external expands to: Unable to access external contract
*/
contract NPS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply;
uint256 public mintPrice;
uint256 public mintMax;
uint256 public holdMax;
address public signer;
bool public open;
string public baseURI;
uint256 public earnings;
address public gateway;
uint256 public maxFreebies;
uint256 public freebieCount;
mapping(uint256 => string) private _tokenURIs;
mapping(address => uint256) public freebies;
mapping(uint256 => bool) public freeTokens;
event Received(address, uint256);
event WithdrawalSuccess(uint256 amount);
struct SettingsStruct {
string name;
string symbol;
uint256 maxSupply;
uint256 mintPrice;
uint256 mintMax;
uint256 holdMax;
address signer;
bool open;
string baseURI;
uint256 earnings;
address gateway;
uint256 totalMinted;
uint256 totalBurned;
uint256 totalSupply;
uint256 maxFreebies;
uint256 freebieCount;
}
constructor(
string memory _name,
string memory _symbol,
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax,
address _signer
) ERC721A(_name, _symbol) {
}
receive() external payable {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function exists(uint256 id) public view returns (bool) {
}
function setBaseURI(string memory newURI) external onlyOwner {
}
function setGateway(address _gateway) external onlyOwner {
}
function setTokenURI(uint256 id, string memory newURI) external onlyOwner {
}
function setMaxSupply(uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function setSigner(address _signer) external onlyOwner {
}
function setOpen(bool _open) external onlyOwner {
}
function setMintPrice(uint256 price) public payable onlyOwner nonReentrant {
}
function setMintMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function setHoldMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function airdrop(address receiver, uint256 amount)
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mint(uint256 quantity) public payable nonReentrant {
}
function mintFreebie(bytes memory signature) public nonReentrant {
require(open, "20:!open");
require(freebieCount < maxFreebies, "20:maxFreebies");
require(maxSupply >= _totalMinted() + 1, "20:maxSupply");
require(<FILL_ME>)
require(freebies[msg.sender] == 0, "20:freebies");
require(_verify(signature), "20:signature");
_buy(msg.sender, 1);
// Map the freebie Ids per wallet
uint256 tokenId = _nextTokenId() - 1;
freebies[msg.sender] = tokenId;
freeTokens[tokenId] = true;
++freebieCount;
}
function mintCrossMint(uint256 quantity, address _to)
public
payable
nonReentrant
{
}
function _buy(address to, uint256 quantity) internal {
}
function burn(uint256 tokenId, bool approvalCheck)
public
payable
nonReentrant
{
}
function withdrawByOwner(address _address, uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function _verify(bytes memory signature) internal view returns (bool) {
}
function _verifyHashSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function setMultiple(
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax
) external onlyOwner {
}
function getSettings() public view returns (SettingsStruct memory) {
}
}
| _numberMinted(msg.sender)+1<=holdMax,"20:holdMax" | 467,446 | _numberMinted(msg.sender)+1<=holdMax |
"20:freebies" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
*Error codes following the convention:
* 10: invalid value
* 20: not allowed
* 30: not enough founds
* 40: contract error
*
* A short description or parameter name must follow the code. Some of these short messages
* can be standardized, but many of them will be project dependant
* For example
* 10:open expands to: Contract not open
* 20:wallet expands to: Wallet not allowed to
* 30:token expands to: Not enough token amounts
* 40:external expands to: Unable to access external contract
*/
contract NPS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply;
uint256 public mintPrice;
uint256 public mintMax;
uint256 public holdMax;
address public signer;
bool public open;
string public baseURI;
uint256 public earnings;
address public gateway;
uint256 public maxFreebies;
uint256 public freebieCount;
mapping(uint256 => string) private _tokenURIs;
mapping(address => uint256) public freebies;
mapping(uint256 => bool) public freeTokens;
event Received(address, uint256);
event WithdrawalSuccess(uint256 amount);
struct SettingsStruct {
string name;
string symbol;
uint256 maxSupply;
uint256 mintPrice;
uint256 mintMax;
uint256 holdMax;
address signer;
bool open;
string baseURI;
uint256 earnings;
address gateway;
uint256 totalMinted;
uint256 totalBurned;
uint256 totalSupply;
uint256 maxFreebies;
uint256 freebieCount;
}
constructor(
string memory _name,
string memory _symbol,
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax,
address _signer
) ERC721A(_name, _symbol) {
}
receive() external payable {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function exists(uint256 id) public view returns (bool) {
}
function setBaseURI(string memory newURI) external onlyOwner {
}
function setGateway(address _gateway) external onlyOwner {
}
function setTokenURI(uint256 id, string memory newURI) external onlyOwner {
}
function setMaxSupply(uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function setSigner(address _signer) external onlyOwner {
}
function setOpen(bool _open) external onlyOwner {
}
function setMintPrice(uint256 price) public payable onlyOwner nonReentrant {
}
function setMintMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function setHoldMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function airdrop(address receiver, uint256 amount)
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mint(uint256 quantity) public payable nonReentrant {
}
function mintFreebie(bytes memory signature) public nonReentrant {
require(open, "20:!open");
require(freebieCount < maxFreebies, "20:maxFreebies");
require(maxSupply >= _totalMinted() + 1, "20:maxSupply");
require(_numberMinted(msg.sender) + 1 <= holdMax, "20:holdMax");
require(<FILL_ME>)
require(_verify(signature), "20:signature");
_buy(msg.sender, 1);
// Map the freebie Ids per wallet
uint256 tokenId = _nextTokenId() - 1;
freebies[msg.sender] = tokenId;
freeTokens[tokenId] = true;
++freebieCount;
}
function mintCrossMint(uint256 quantity, address _to)
public
payable
nonReentrant
{
}
function _buy(address to, uint256 quantity) internal {
}
function burn(uint256 tokenId, bool approvalCheck)
public
payable
nonReentrant
{
}
function withdrawByOwner(address _address, uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function _verify(bytes memory signature) internal view returns (bool) {
}
function _verifyHashSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function setMultiple(
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax
) external onlyOwner {
}
function getSettings() public view returns (SettingsStruct memory) {
}
}
| freebies[msg.sender]==0,"20:freebies" | 467,446 | freebies[msg.sender]==0 |
"20:signature" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
*Error codes following the convention:
* 10: invalid value
* 20: not allowed
* 30: not enough founds
* 40: contract error
*
* A short description or parameter name must follow the code. Some of these short messages
* can be standardized, but many of them will be project dependant
* For example
* 10:open expands to: Contract not open
* 20:wallet expands to: Wallet not allowed to
* 30:token expands to: Not enough token amounts
* 40:external expands to: Unable to access external contract
*/
contract NPS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply;
uint256 public mintPrice;
uint256 public mintMax;
uint256 public holdMax;
address public signer;
bool public open;
string public baseURI;
uint256 public earnings;
address public gateway;
uint256 public maxFreebies;
uint256 public freebieCount;
mapping(uint256 => string) private _tokenURIs;
mapping(address => uint256) public freebies;
mapping(uint256 => bool) public freeTokens;
event Received(address, uint256);
event WithdrawalSuccess(uint256 amount);
struct SettingsStruct {
string name;
string symbol;
uint256 maxSupply;
uint256 mintPrice;
uint256 mintMax;
uint256 holdMax;
address signer;
bool open;
string baseURI;
uint256 earnings;
address gateway;
uint256 totalMinted;
uint256 totalBurned;
uint256 totalSupply;
uint256 maxFreebies;
uint256 freebieCount;
}
constructor(
string memory _name,
string memory _symbol,
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax,
address _signer
) ERC721A(_name, _symbol) {
}
receive() external payable {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function exists(uint256 id) public view returns (bool) {
}
function setBaseURI(string memory newURI) external onlyOwner {
}
function setGateway(address _gateway) external onlyOwner {
}
function setTokenURI(uint256 id, string memory newURI) external onlyOwner {
}
function setMaxSupply(uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function setSigner(address _signer) external onlyOwner {
}
function setOpen(bool _open) external onlyOwner {
}
function setMintPrice(uint256 price) public payable onlyOwner nonReentrant {
}
function setMintMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function setHoldMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function airdrop(address receiver, uint256 amount)
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mint(uint256 quantity) public payable nonReentrant {
}
function mintFreebie(bytes memory signature) public nonReentrant {
require(open, "20:!open");
require(freebieCount < maxFreebies, "20:maxFreebies");
require(maxSupply >= _totalMinted() + 1, "20:maxSupply");
require(_numberMinted(msg.sender) + 1 <= holdMax, "20:holdMax");
require(freebies[msg.sender] == 0, "20:freebies");
require(<FILL_ME>)
_buy(msg.sender, 1);
// Map the freebie Ids per wallet
uint256 tokenId = _nextTokenId() - 1;
freebies[msg.sender] = tokenId;
freeTokens[tokenId] = true;
++freebieCount;
}
function mintCrossMint(uint256 quantity, address _to)
public
payable
nonReentrant
{
}
function _buy(address to, uint256 quantity) internal {
}
function burn(uint256 tokenId, bool approvalCheck)
public
payable
nonReentrant
{
}
function withdrawByOwner(address _address, uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function _verify(bytes memory signature) internal view returns (bool) {
}
function _verifyHashSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function setMultiple(
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax
) external onlyOwner {
}
function getSettings() public view returns (SettingsStruct memory) {
}
}
| _verify(signature),"20:signature" | 467,446 | _verify(signature) |
"20:holdMax" | // SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.12;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
*Error codes following the convention:
* 10: invalid value
* 20: not allowed
* 30: not enough founds
* 40: contract error
*
* A short description or parameter name must follow the code. Some of these short messages
* can be standardized, but many of them will be project dependant
* For example
* 10:open expands to: Contract not open
* 20:wallet expands to: Wallet not allowed to
* 30:token expands to: Not enough token amounts
* 40:external expands to: Unable to access external contract
*/
contract NPS is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
uint256 public maxSupply;
uint256 public mintPrice;
uint256 public mintMax;
uint256 public holdMax;
address public signer;
bool public open;
string public baseURI;
uint256 public earnings;
address public gateway;
uint256 public maxFreebies;
uint256 public freebieCount;
mapping(uint256 => string) private _tokenURIs;
mapping(address => uint256) public freebies;
mapping(uint256 => bool) public freeTokens;
event Received(address, uint256);
event WithdrawalSuccess(uint256 amount);
struct SettingsStruct {
string name;
string symbol;
uint256 maxSupply;
uint256 mintPrice;
uint256 mintMax;
uint256 holdMax;
address signer;
bool open;
string baseURI;
uint256 earnings;
address gateway;
uint256 totalMinted;
uint256 totalBurned;
uint256 totalSupply;
uint256 maxFreebies;
uint256 freebieCount;
}
constructor(
string memory _name,
string memory _symbol,
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax,
address _signer
) ERC721A(_name, _symbol) {
}
receive() external payable {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function totalMinted() public view returns (uint256) {
}
function totalBurned() public view returns (uint256) {
}
function nextTokenId() public view returns (uint256) {
}
function exists(uint256 id) public view returns (bool) {
}
function setBaseURI(string memory newURI) external onlyOwner {
}
function setGateway(address _gateway) external onlyOwner {
}
function setTokenURI(uint256 id, string memory newURI) external onlyOwner {
}
function setMaxSupply(uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function setSigner(address _signer) external onlyOwner {
}
function setOpen(bool _open) external onlyOwner {
}
function setMintPrice(uint256 price) public payable onlyOwner nonReentrant {
}
function setMintMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function setHoldMax(uint256 limit) public payable onlyOwner nonReentrant {
}
function airdrop(address receiver, uint256 amount)
public
onlyOwner
nonReentrant
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mint(uint256 quantity) public payable nonReentrant {
}
function mintFreebie(bytes memory signature) public nonReentrant {
}
function mintCrossMint(uint256 quantity, address _to)
public
payable
nonReentrant
{
require(msg.sender == gateway, "20:gateway");
require(open, "20:!open");
require(quantity > 0, "10:quantity");
require(quantity <= mintMax, "20:mintMax");
require(maxSupply >= _totalMinted() + quantity, "20:maxSupply");
require(<FILL_ME>)
_buy(_to, quantity);
earnings += quantity * mintPrice;
}
function _buy(address to, uint256 quantity) internal {
}
function burn(uint256 tokenId, bool approvalCheck)
public
payable
nonReentrant
{
}
function withdrawByOwner(address _address, uint256 amount)
public
payable
onlyOwner
nonReentrant
{
}
function _verify(bytes memory signature) internal view returns (bool) {
}
function _verifyHashSignature(bytes32 hash, bytes memory signature)
internal
view
returns (bool)
{
}
function setMultiple(
uint256 _maxSupply,
uint256 _mintPrice,
uint256 _mintMax,
uint256 _holdMax
) external onlyOwner {
}
function getSettings() public view returns (SettingsStruct memory) {
}
}
| _numberMinted(_to)+quantity<=holdMax,"20:holdMax" | 467,446 | _numberMinted(_to)+quantity<=holdMax |
"Pass does not contain that tokenId" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
contract ERC721Staked is ERC721, Ownable, ERC721Holder {
using Strings for uint;
IERC721 public nft;
struct StakerWallet {
uint[] maskTokenIds;
mapping(uint => uint) timeStaked;
}
string public contractURI;
string public baseTokenURI;
string public baseTokenURIExpress;
string public baseTokenURIGold;
uint public expressPass;
uint public goldPass;
uint public totalStaked;
uint public mintId;
mapping(uint => StakerWallet) Stakers;
mapping(uint => bool) public rareMasks;
mapping(uint => uint) public tokenOwner;
constructor(address _nft, string memory _name, string memory _symbol, string memory _contractURI, string memory _baseTokenURI, string memory _baseTokenURIExpress, string memory _baseTokenURIGold) ERC721(_name, _symbol) {
}
//view functions
function getStakedTokens(uint _tokenId) public view returns (uint[] memory tokens) {
}
function getStakedTime(uint _tokenId) public view returns (uint stakeTime) {
}
function hasRare(uint _tokenId) public view returns (bool) {
}
function passType(uint _tokenId) public view returns (uint) {
}
function tokenURI(uint _tokenId) public view override returns (string memory) {
}
//stake
function stake(address user, uint tokenID) public {
}
function batchStake(address user, uint[] memory tokenIDs) public {
}
function _stake(address _user, uint _tokenId, uint _newTokenId) internal {
}
//unstake
function unstake(address user, uint tokenId, uint maskTokenID) public {
}
function batchUnstake(address user, uint tokenId, uint[] memory maskTokenIds) public {
}
function _unstake(address _user, uint _tokenId, uint _maskTokenId) internal {
require(_isApprovedOrOwner(msg.sender, _tokenId), "Not an operator for this tokenId");
require(<FILL_ME>)
//get Staker Wallet
StakerWallet storage _staker = Stakers[_tokenId];
//transfer ownership back to user
// nft.approve(_user, _maskTokenId);
nft.safeTransferFrom(address(this), _user, _maskTokenId);
//clear out staked info
delete tokenOwner[_tokenId];
delete _staker.timeStaked[_tokenId];
totalStaked--;
//replace the removed token id at its current index with the last value in the array
//and then pop() off the last index. We do not care about the order of this
//array
bool done = false;
uint i = 0;
do {
// for (uint i = 0; i < _staker.maskTokenIds.length - 1; i++) { //this seems to defeat purpose of while loop
if (_staker.maskTokenIds[i] == _maskTokenId) {
_staker.maskTokenIds[i] = _staker.maskTokenIds[_staker.maskTokenIds.length - 1];
_staker.maskTokenIds.pop();
done = true;
}
// }
i++;
} while (done == false);
if (passType(_tokenId) == 0) {
_burn(_tokenId);
}
}
//uniswap multicall
function multicall(bytes[] calldata data) external payable returns (bytes[] memory results) {
}
function setBaseTokenURIGeneral(string memory _baseTokenURIGeneral) external onlyOwner {
}
function setBaseTokenURIExpress(string memory _baseTokenURIExpress) external onlyOwner {
}
function setBaseTokenURIGold(string memory _baseTokenURIGold) external onlyOwner {
}
function setExpressPass(uint _expressPass) external onlyOwner {
}
function setGoldPass(uint _goldPass) external onlyOwner {
}
function setRareMask(uint _tokenId) external onlyOwner {
}
function setRareMasks(uint[] memory _tokenIds) external onlyOwner {
}
function revokeRareMask(uint _tokenId) external onlyOwner {
}
function revokeRareMasks(uint[] memory _tokenIds) external onlyOwner {
}
}
| tokenOwner[_maskTokenId]==_tokenId,"Pass does not contain that tokenId" | 467,459 | tokenOwner[_maskTokenId]==_tokenId |
"Presale: No tokens to claim" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
library SafeMath {
function tryAdd(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
pragma solidity ^0.8.0;
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
);
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
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 {
}
}
pragma solidity ^0.8.0;
contract OwnerWithdrawable is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
receive() external payable {}
fallback() external payable {}
function withdraw(address token, uint256 amt) public onlyOwner {
}
function withdrawAll(address token) public onlyOwner {
}
function withdrawCurrency(uint256 amt) public onlyOwner {
}
// function deposit(address token, uint256 amt) public onlyOwner {
// uint256 allowance = IERC20(token).allowance(msg.sender, address(this));
// require(allowance >= amt, "Check the token allowance");
// IERC20(token).transferFrom(owner(), address(this), amt);
// }
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data
) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
pragma solidity ^0.8.0;
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
pragma solidity ^0.8.0;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
contract MemePresale is OwnerWithdrawable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using SafeERC20 for IERC20Metadata;
uint256 public rate;
address public saleToken;
uint public saleTokenDec;
uint256 public totalTokensforSale;
mapping(address => bool) public payableTokens;
mapping(address => uint256) public tokenPrices;
bool public saleStatus;
address[] public buyers;
mapping(address => BuyerTokenDetails) public buyersAmount;
uint256 public totalTokensSold;
struct BuyerTokenDetails {
uint amount;
bool exists;
bool isClaimed;
}
constructor() {
}
modifier saleEnabled() {
}
modifier saleStoped() {
}
function setSaleToken(
address _saleToken,
uint256 _totalTokensforSale,
uint256 _rate,
bool _saleStatus
) external onlyOwner {
}
function stopSale() external onlyOwner {
}
function resumeSale() external onlyOwner {
}
function addPayableTokens(
address[] memory _tokens,
uint256[] memory _prices
) external onlyOwner {
}
function payableTokenStatus(
address _token,
bool _status
) external onlyOwner {
}
function updateTokenRate(
address[] memory _tokens,
uint256[] memory _prices,
uint256 _rate
) external onlyOwner {
}
function getTokenAmount(
address token,
uint256 amount
) public view returns (uint256) {
}
function buyToken(
address _token,
uint256 _amount
) external payable saleEnabled {
}
function unlockToken() external payable saleStoped {
require(<FILL_ME>)
uint256 tokensforWithdraw = buyersAmount[msg.sender].amount;
buyersAmount[msg.sender].amount = 0;
IERC20(saleToken).safeTransfer(msg.sender, tokensforWithdraw);
}
// Method to unlock all the tokens
function unlockAllTokens() external onlyOwner saleStoped {
}
function withdrawAllSaleTokens() external onlyOwner saleStoped {
}
}
| buyersAmount[msg.sender].amount>0,"Presale: No tokens to claim" | 467,462 | buyersAmount[msg.sender].amount>0 |
"Too Much" | pragma solidity ^0.8.4;
contract Parapad is Ownable {
using SafeERC20 for IERC20;
address public usdtAddress;
address public paradoxAddress;
IERC20 internal para;
IERC20 internal usdt;
mapping(address => bool) public _claimed;
uint256 constant internal PARADOX_DECIMALS = 10 ** 18;
uint256 constant internal USDT_DECIMALS = 10 ** 6;
uint256 constant internal EXCHANGE_RATE = 3;
uint256 constant internal EXCHANGE_RATE_DENOMINATOR = 100;
uint256 constant internal MONTH = 4 weeks;
/** MAXIMUM OF $1000 per person */
uint256 constant internal MAX_AMOUNT = 1000 * USDT_DECIMALS;
mapping(address => Lock) public locks;
struct Lock {
uint256 total;
uint256 paid;
uint256 debt;
uint256 startTime;
}
constructor (address _usdt, address _paradox) {
}
function getClaimed(address _user) external view returns (bool) {
}
function buyParadox(
uint256 amount
) external {
require(!_claimed[msg.sender], "Limit reached");
require(amount <= MAX_AMOUNT, "Wrong amount");
// get exchange rate to para
uint256 rate = amount * EXCHANGE_RATE_DENOMINATOR * PARADOX_DECIMALS / (USDT_DECIMALS * EXCHANGE_RATE);
require(rate <= para.balanceOf(address(this)), "Low balance");
// give user 20% now
uint256 rateNow = rate * 20 / 100;
uint256 vestingRate = rate - rateNow;
if (locks[msg.sender].total == 0) {
// new claim
locks[msg.sender] = Lock({
total: vestingRate,
paid: amount,
debt: 0,
startTime: block.timestamp
});
if (amount == MAX_AMOUNT) _claimed[msg.sender] = true;
} else {
// at this point, the user still has some pending amount they can claim
require(<FILL_ME>)
locks[msg.sender].total += vestingRate;
if (amount + locks[msg.sender].paid == MAX_AMOUNT) _claimed[msg.sender] = true;
locks[msg.sender].paid += amount;
}
usdt.safeTransferFrom(msg.sender, address(this), amount);
para.safeTransfer(msg.sender, rateNow);
}
// New Function
function pendingVestedParadox(address _user) external view returns(uint256) {
}
// New Function
function claimVestedParadox() external {
}
function withdrawTether(address _destination) external onlyOwner {
}
/** @notice EMERGENCY FUNCTIONS */
function updateClaimed(address _user) external onlyOwner {
}
function updateUserLock(address _user, uint256 _total, uint256 _paid, uint256 _startTime) external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
function withdrawParadox() external onlyOwner {
}
}
| amount+locks[msg.sender].paid<=MAX_AMOUNT,"Too Much" | 467,523 | amount+locks[msg.sender].paid<=MAX_AMOUNT |
"already exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../access/GenArtAccess.sol";
import "../factory/GenArtCollectionFactory.sol";
import "../factory/GenArtPaymentSplitterFactory.sol";
import "../interface/IGenArtERC721.sol";
import "../interface/IGenArtMinter.sol";
/**
* @dev GEN.ART Curated
* Admin of {GenArtCollectionFactory} and {GenArtPaymentSplitterFactory}
*/
contract GenArtCurated is GenArtAccess {
struct Collection {
uint256 id;
address artist;
address contractAddress;
uint256 maxSupply;
string script;
}
struct Artist {
address wallet;
address[] collections;
address paymentSplitter;
}
struct CollectionInfo {
string name;
string symbol;
address minter;
Collection collection;
Artist artist;
}
mapping(address => Collection) public collections;
mapping(address => Artist) public artists;
address public collectionFactory;
address public paymentSplitterFactory;
event ScriptUpdated(address collection, string script);
constructor(address collectionFactory_, address paymentSplitterFactory_) {
}
/**
* @dev Internal functtion to close the ERC721 implementation contract
*/
function _cloneCollection(CollectionParams memory params)
internal
returns (address instance, uint256 id)
{
}
/**
* @dev Internal functtion to create the collection and risgister to minter
*/
function _createCollection(CollectionParams memory params)
internal
returns (address instance, uint256 id)
{
}
/**
* @dev Clones an ERC721 implementation contract
* @param artist address of artist
* @param name name of collection
* @param symbol ERC721 symbol for collection
* @param script single html as string
* @param maxSupply max token supply
* @param erc721Index ERC721 implementation index
* @param minterIndex minter index
*/
function createCollection(
address artist,
string memory name,
string memory symbol,
string memory script,
bool hasOnChainScript,
uint256 maxSupply,
uint8 erc721Index,
uint8 minterIndex
) external onlyAdmin {
}
/**
* @dev Get all available mints for account
* @param artist address of artist
* @param payeesMint address list of payees of mint proceeds
* @param payeesRoyalties address list of payees of royalties
* @param sharesMint list of shares for mint proceeds
* @param sharesRoyalties list of shares for royalties
* Note payee and shares indices must be in respective order
*/
function createArtist(
address artist,
address[] memory payeesMint,
address[] memory payeesRoyalties,
uint256[] memory sharesMint,
uint256[] memory sharesRoyalties
) external onlyAdmin {
require(<FILL_ME>)
address paymentSplitter = GenArtPaymentSplitterFactory(
paymentSplitterFactory
).clone(
genartAdmin,
artist,
payeesMint,
payeesRoyalties,
sharesMint,
sharesRoyalties
);
address[] memory collections_;
artists[artist] = Artist(artist, collections_, paymentSplitter);
}
/**
* @dev Helper function to get {PaymentSplitter} of artist
*/
function getPaymentSplitterForCollection(address collection)
external
view
returns (address)
{
}
/**
* @dev Get artist struct
* @param artist adress of artist
*/
function getArtist(address artist) external view returns (Artist memory) {
}
/**
* @dev Get collection info
* @param collection contract address of the collection
*/
function getCollectionInfo(address collection)
external
view
returns (CollectionInfo memory info)
{
}
/**
* @dev Set the {GenArtCollectionFactory} contract address
*/
function setCollectionFactory(address factory) external onlyAdmin {
}
/**
* @dev Set the {GenArtPaymentSplitterFactory} contract address
*/
function setPaymentSplitterFactory(address factory) external onlyAdmin {
}
/**
* @dev Update script of collection
* @param collection contract address of the collection
* @param script single html as string
*/
function updateScript(address collection, string memory script) external {
}
}
| artists[artist].wallet==address(0),"already exists" | 467,549 | artists[artist].wallet==address(0) |
"not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../access/GenArtAccess.sol";
import "../factory/GenArtCollectionFactory.sol";
import "../factory/GenArtPaymentSplitterFactory.sol";
import "../interface/IGenArtERC721.sol";
import "../interface/IGenArtMinter.sol";
/**
* @dev GEN.ART Curated
* Admin of {GenArtCollectionFactory} and {GenArtPaymentSplitterFactory}
*/
contract GenArtCurated is GenArtAccess {
struct Collection {
uint256 id;
address artist;
address contractAddress;
uint256 maxSupply;
string script;
}
struct Artist {
address wallet;
address[] collections;
address paymentSplitter;
}
struct CollectionInfo {
string name;
string symbol;
address minter;
Collection collection;
Artist artist;
}
mapping(address => Collection) public collections;
mapping(address => Artist) public artists;
address public collectionFactory;
address public paymentSplitterFactory;
event ScriptUpdated(address collection, string script);
constructor(address collectionFactory_, address paymentSplitterFactory_) {
}
/**
* @dev Internal functtion to close the ERC721 implementation contract
*/
function _cloneCollection(CollectionParams memory params)
internal
returns (address instance, uint256 id)
{
}
/**
* @dev Internal functtion to create the collection and risgister to minter
*/
function _createCollection(CollectionParams memory params)
internal
returns (address instance, uint256 id)
{
}
/**
* @dev Clones an ERC721 implementation contract
* @param artist address of artist
* @param name name of collection
* @param symbol ERC721 symbol for collection
* @param script single html as string
* @param maxSupply max token supply
* @param erc721Index ERC721 implementation index
* @param minterIndex minter index
*/
function createCollection(
address artist,
string memory name,
string memory symbol,
string memory script,
bool hasOnChainScript,
uint256 maxSupply,
uint8 erc721Index,
uint8 minterIndex
) external onlyAdmin {
}
/**
* @dev Get all available mints for account
* @param artist address of artist
* @param payeesMint address list of payees of mint proceeds
* @param payeesRoyalties address list of payees of royalties
* @param sharesMint list of shares for mint proceeds
* @param sharesRoyalties list of shares for royalties
* Note payee and shares indices must be in respective order
*/
function createArtist(
address artist,
address[] memory payeesMint,
address[] memory payeesRoyalties,
uint256[] memory sharesMint,
uint256[] memory sharesRoyalties
) external onlyAdmin {
}
/**
* @dev Helper function to get {PaymentSplitter} of artist
*/
function getPaymentSplitterForCollection(address collection)
external
view
returns (address)
{
}
/**
* @dev Get artist struct
* @param artist adress of artist
*/
function getArtist(address artist) external view returns (Artist memory) {
}
/**
* @dev Get collection info
* @param collection contract address of the collection
*/
function getCollectionInfo(address collection)
external
view
returns (CollectionInfo memory info)
{
}
/**
* @dev Set the {GenArtCollectionFactory} contract address
*/
function setCollectionFactory(address factory) external onlyAdmin {
}
/**
* @dev Set the {GenArtPaymentSplitterFactory} contract address
*/
function setPaymentSplitterFactory(address factory) external onlyAdmin {
}
/**
* @dev Update script of collection
* @param collection contract address of the collection
* @param script single html as string
*/
function updateScript(address collection, string memory script) external {
address sender = _msgSender();
require(<FILL_ME>)
collections[collection].script = script;
emit ScriptUpdated(collection, script);
}
}
| collections[collection].artist==sender||admins[sender]||owner()==sender,"not allowed" | 467,549 | collections[collection].artist==sender||admins[sender]||owner()==sender |
"you received more than 1 nft" | pragma solidity 0.8.4;
contract QuantRolePlay is ERC721A{
string public baseTokenURI;
string public tokenURI1 = "https://ivory-causal-goat-321.mypinata.cloud/ipfs/QmUFZWdB7VCatTuU6AricXSm3bPXyNcNCpqrPPSNsiL1qg/";
bool checkWL;
bool checkGuaranteed;
bool checkAllNFT;
uint countWL;
uint countGuaranteed;
mapping (address => uint256) WLadr;
mapping (address => uint256) Guaranteedadr;
address owner;
constructor() ERC721A("Quant Role Play", "QRP"){
}
function mintComandDevelopers() public {
}
function CheckOwner() public view returns (address){
}
function TransferOwnersRules(address newOwner) public {
}
function WL() public payable {
require(checkWL == true, "not active");
require(countWL > 0,"Lost count");
require(msg.value >= 0.009 ether, "No ETHER");
require(<FILL_ME>)
_mint(msg.sender,1,"",false);
WLadr[msg.sender]++;
countWL--;
}
function Guaranteed() public payable {
}
function AllNFT() public payable {
}
function SetcheckGuaranteed() public {
}
function SetcheckAllNFT() public {
}
function SetcheckWL() public {
}
function Withdraw() public {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenURI(string memory _baseTokenURI) public {
}
function setURI(string memory newURI) public {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| WLadr[msg.sender]<2,"you received more than 1 nft" | 467,751 | WLadr[msg.sender]<2 |
"you received more than 1 nft" | pragma solidity 0.8.4;
contract QuantRolePlay is ERC721A{
string public baseTokenURI;
string public tokenURI1 = "https://ivory-causal-goat-321.mypinata.cloud/ipfs/QmUFZWdB7VCatTuU6AricXSm3bPXyNcNCpqrPPSNsiL1qg/";
bool checkWL;
bool checkGuaranteed;
bool checkAllNFT;
uint countWL;
uint countGuaranteed;
mapping (address => uint256) WLadr;
mapping (address => uint256) Guaranteedadr;
address owner;
constructor() ERC721A("Quant Role Play", "QRP"){
}
function mintComandDevelopers() public {
}
function CheckOwner() public view returns (address){
}
function TransferOwnersRules(address newOwner) public {
}
function WL() public payable {
}
function Guaranteed() public payable {
require(checkGuaranteed == true, "not active");
require(countGuaranteed > 0,"Lost count");
require(msg.value >= 0.009 ether, "No ETHER");
require(<FILL_ME>)
Guaranteedadr[msg.sender]++;
_mint(msg.sender,1,"",false);
countGuaranteed--;
}
function AllNFT() public payable {
}
function SetcheckGuaranteed() public {
}
function SetcheckAllNFT() public {
}
function SetcheckWL() public {
}
function Withdraw() public {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenURI(string memory _baseTokenURI) public {
}
function setURI(string memory newURI) public {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| Guaranteedadr[msg.sender]<2,"you received more than 1 nft" | 467,751 | Guaranteedadr[msg.sender]<2 |
"Sniper blocked" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract ArabicStrawberryElephant is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
address public uniV2router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
bool private swapping;
address public marketingWallet;
address public developmentWallet;
address public liquidityWallet;
address public operationsWallet;
uint256 public maxTransaction;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 private launchBlock;
mapping(address => bool) public blocked;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevelopmentFee;
uint256 public buyOperationsFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevelopmentFee;
uint256 public sellOperationsFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDevelopment;
uint256 public tokensForOperations;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedmaxTransaction;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event developmentWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event liquidityWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event operationsWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event routerUpdated(
address indexed newRouter,
address indexed oldRouter
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Arabic Strawberry Elephant", unicode"صباح فراوله") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// disable Transfer delay - cannot be reenabled
function disableDelay() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTransaction(uint256 newNum) external onlyOwner {
}
function updateMaxWallet(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _developmentFee,
uint256 _operationsFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _developmentFee,
uint256 _operationsFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updatemarketingWallet(address newmarketingWallet) external onlyOwner {
}
function updatedevelopmentWallet(address newWallet) external onlyOwner {
}
function updateoperationsWallet(address newWallet) external onlyOwner{
}
function updateliquidityWallet(address newliquidityWallet) external onlyOwner {
}
function updateRouter(address newRouter) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedmaxTransaction[to]
) {
require(
amount <= maxTransaction,
"Buy transfer amount exceeds the maxTransaction."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedmaxTransaction[from]
) {
require(
amount <= maxTransaction,
"Sell transfer amount exceeds the maxTransaction."
);
} else if (!_isExcludedmaxTransaction[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForDevelopment += (fees * sellDevelopmentFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
tokensForOperations += (fees * sellOperationsFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDevelopment += (fees * buyDevelopmentFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
tokensForOperations += (fees * buyOperationsFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateBL(address[] calldata blockees, bool shouldBlock) external onlyOwner {
}
function swapBack() private {
}
}
| !blocked[from],"Sniper blocked" | 467,958 | !blocked[from] |
"User is not whitelisted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract BadBulls is ERC721A, Ownable {
using ECDSA for bytes32;
bool public isSaleActive = false;
bool public isWhiteListActive = true;
uint256 public maxSupply = 10000;
uint256 public maxMint = 5;
uint256 public publicSaleTokenPrice = 0.07 ether;
uint256 public presaleTokenPrice = 0.05 ether;
string private _baseTokenURI;
address private whitelistAccount =
0xF629C1F48A29dcfC48F52d50C4690F16A70ee679;
address private freelistAccount =
0x0f64EfcFfBBc95946576Fc8B8AfB2Cb205f64C0b;
mapping(bytes32 => bool) whitelistCalimed;
mapping(bytes32 => bool) freelistCalimed;
event minted(address indexed _to);
constructor(
string memory baseURI_,
address _whitelistAccount,
address _freelistAccount
) ERC721A("Bad Bulls", "BBULL") {
}
function mintWhitelist(
uint8 numberOfTokens,
bytes32 messageHash,
bytes memory _signature
) external payable {
uint256 ts = totalSupply();
require(isWhiteListActive, "Whitelist is not active");
require(<FILL_ME>)
require(!whitelistCalimed[messageHash], "Address has already cleaimed");
require(numberOfTokens <= maxMint, "Exceeded max token purchase");
require(
ts + numberOfTokens <= maxSupply,
"Purchase would exceed max tokens"
);
require(
presaleTokenPrice * numberOfTokens <= msg.value,
"Ether value sent is not correct"
);
_safeMint(msg.sender, numberOfTokens);
whitelistCalimed[messageHash] = true;
emit minted(msg.sender);
}
function mintFree(bytes32 messageHash, bytes memory _signature)
external
payable
{
}
function mint(uint256 numberOfTokens) external payable {
}
function isWhitelisted(bytes32 hash, bytes memory _signature)
private
pure
returns (address)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mintToAddress(address _address, uint256 n) external onlyOwner {
}
function setIsSaleState(bool newState) external onlyOwner {
}
function setIsWhiteListActive(bool _isWhiteListActive) external onlyOwner {
}
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function updateMaxMint(uint256 _maxMint) external onlyOwner {
}
function updatePublicSalePrice(uint256 _publicSaleTokenPrice)
external
onlyOwner
{
}
function updatePreSalePrice(uint256 _preSaleTokenPrice) external onlyOwner {
}
function setWhitelistAccount(address _whitelistAccount) external onlyOwner {
}
function setFreelistAccount(address _freelistAccount) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| isWhitelisted(messageHash,_signature)==whitelistAccount,"User is not whitelisted!" | 468,063 | isWhitelisted(messageHash,_signature)==whitelistAccount |
"Address has already cleaimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract BadBulls is ERC721A, Ownable {
using ECDSA for bytes32;
bool public isSaleActive = false;
bool public isWhiteListActive = true;
uint256 public maxSupply = 10000;
uint256 public maxMint = 5;
uint256 public publicSaleTokenPrice = 0.07 ether;
uint256 public presaleTokenPrice = 0.05 ether;
string private _baseTokenURI;
address private whitelistAccount =
0xF629C1F48A29dcfC48F52d50C4690F16A70ee679;
address private freelistAccount =
0x0f64EfcFfBBc95946576Fc8B8AfB2Cb205f64C0b;
mapping(bytes32 => bool) whitelistCalimed;
mapping(bytes32 => bool) freelistCalimed;
event minted(address indexed _to);
constructor(
string memory baseURI_,
address _whitelistAccount,
address _freelistAccount
) ERC721A("Bad Bulls", "BBULL") {
}
function mintWhitelist(
uint8 numberOfTokens,
bytes32 messageHash,
bytes memory _signature
) external payable {
uint256 ts = totalSupply();
require(isWhiteListActive, "Whitelist is not active");
require(
isWhitelisted(messageHash, _signature) == whitelistAccount,
"User is not whitelisted!"
);
require(<FILL_ME>)
require(numberOfTokens <= maxMint, "Exceeded max token purchase");
require(
ts + numberOfTokens <= maxSupply,
"Purchase would exceed max tokens"
);
require(
presaleTokenPrice * numberOfTokens <= msg.value,
"Ether value sent is not correct"
);
_safeMint(msg.sender, numberOfTokens);
whitelistCalimed[messageHash] = true;
emit minted(msg.sender);
}
function mintFree(bytes32 messageHash, bytes memory _signature)
external
payable
{
}
function mint(uint256 numberOfTokens) external payable {
}
function isWhitelisted(bytes32 hash, bytes memory _signature)
private
pure
returns (address)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mintToAddress(address _address, uint256 n) external onlyOwner {
}
function setIsSaleState(bool newState) external onlyOwner {
}
function setIsWhiteListActive(bool _isWhiteListActive) external onlyOwner {
}
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function updateMaxMint(uint256 _maxMint) external onlyOwner {
}
function updatePublicSalePrice(uint256 _publicSaleTokenPrice)
external
onlyOwner
{
}
function updatePreSalePrice(uint256 _preSaleTokenPrice) external onlyOwner {
}
function setWhitelistAccount(address _whitelistAccount) external onlyOwner {
}
function setFreelistAccount(address _freelistAccount) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| !whitelistCalimed[messageHash],"Address has already cleaimed" | 468,063 | !whitelistCalimed[messageHash] |
"Purchase would exceed max tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract BadBulls is ERC721A, Ownable {
using ECDSA for bytes32;
bool public isSaleActive = false;
bool public isWhiteListActive = true;
uint256 public maxSupply = 10000;
uint256 public maxMint = 5;
uint256 public publicSaleTokenPrice = 0.07 ether;
uint256 public presaleTokenPrice = 0.05 ether;
string private _baseTokenURI;
address private whitelistAccount =
0xF629C1F48A29dcfC48F52d50C4690F16A70ee679;
address private freelistAccount =
0x0f64EfcFfBBc95946576Fc8B8AfB2Cb205f64C0b;
mapping(bytes32 => bool) whitelistCalimed;
mapping(bytes32 => bool) freelistCalimed;
event minted(address indexed _to);
constructor(
string memory baseURI_,
address _whitelistAccount,
address _freelistAccount
) ERC721A("Bad Bulls", "BBULL") {
}
function mintWhitelist(
uint8 numberOfTokens,
bytes32 messageHash,
bytes memory _signature
) external payable {
uint256 ts = totalSupply();
require(isWhiteListActive, "Whitelist is not active");
require(
isWhitelisted(messageHash, _signature) == whitelistAccount,
"User is not whitelisted!"
);
require(!whitelistCalimed[messageHash], "Address has already cleaimed");
require(numberOfTokens <= maxMint, "Exceeded max token purchase");
require(<FILL_ME>)
require(
presaleTokenPrice * numberOfTokens <= msg.value,
"Ether value sent is not correct"
);
_safeMint(msg.sender, numberOfTokens);
whitelistCalimed[messageHash] = true;
emit minted(msg.sender);
}
function mintFree(bytes32 messageHash, bytes memory _signature)
external
payable
{
}
function mint(uint256 numberOfTokens) external payable {
}
function isWhitelisted(bytes32 hash, bytes memory _signature)
private
pure
returns (address)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mintToAddress(address _address, uint256 n) external onlyOwner {
}
function setIsSaleState(bool newState) external onlyOwner {
}
function setIsWhiteListActive(bool _isWhiteListActive) external onlyOwner {
}
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function updateMaxMint(uint256 _maxMint) external onlyOwner {
}
function updatePublicSalePrice(uint256 _publicSaleTokenPrice)
external
onlyOwner
{
}
function updatePreSalePrice(uint256 _preSaleTokenPrice) external onlyOwner {
}
function setWhitelistAccount(address _whitelistAccount) external onlyOwner {
}
function setFreelistAccount(address _freelistAccount) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| ts+numberOfTokens<=maxSupply,"Purchase would exceed max tokens" | 468,063 | ts+numberOfTokens<=maxSupply |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract BadBulls is ERC721A, Ownable {
using ECDSA for bytes32;
bool public isSaleActive = false;
bool public isWhiteListActive = true;
uint256 public maxSupply = 10000;
uint256 public maxMint = 5;
uint256 public publicSaleTokenPrice = 0.07 ether;
uint256 public presaleTokenPrice = 0.05 ether;
string private _baseTokenURI;
address private whitelistAccount =
0xF629C1F48A29dcfC48F52d50C4690F16A70ee679;
address private freelistAccount =
0x0f64EfcFfBBc95946576Fc8B8AfB2Cb205f64C0b;
mapping(bytes32 => bool) whitelistCalimed;
mapping(bytes32 => bool) freelistCalimed;
event minted(address indexed _to);
constructor(
string memory baseURI_,
address _whitelistAccount,
address _freelistAccount
) ERC721A("Bad Bulls", "BBULL") {
}
function mintWhitelist(
uint8 numberOfTokens,
bytes32 messageHash,
bytes memory _signature
) external payable {
uint256 ts = totalSupply();
require(isWhiteListActive, "Whitelist is not active");
require(
isWhitelisted(messageHash, _signature) == whitelistAccount,
"User is not whitelisted!"
);
require(!whitelistCalimed[messageHash], "Address has already cleaimed");
require(numberOfTokens <= maxMint, "Exceeded max token purchase");
require(
ts + numberOfTokens <= maxSupply,
"Purchase would exceed max tokens"
);
require(<FILL_ME>)
_safeMint(msg.sender, numberOfTokens);
whitelistCalimed[messageHash] = true;
emit minted(msg.sender);
}
function mintFree(bytes32 messageHash, bytes memory _signature)
external
payable
{
}
function mint(uint256 numberOfTokens) external payable {
}
function isWhitelisted(bytes32 hash, bytes memory _signature)
private
pure
returns (address)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mintToAddress(address _address, uint256 n) external onlyOwner {
}
function setIsSaleState(bool newState) external onlyOwner {
}
function setIsWhiteListActive(bool _isWhiteListActive) external onlyOwner {
}
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function updateMaxMint(uint256 _maxMint) external onlyOwner {
}
function updatePublicSalePrice(uint256 _publicSaleTokenPrice)
external
onlyOwner
{
}
function updatePreSalePrice(uint256 _preSaleTokenPrice) external onlyOwner {
}
function setWhitelistAccount(address _whitelistAccount) external onlyOwner {
}
function setFreelistAccount(address _freelistAccount) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| presaleTokenPrice*numberOfTokens<=msg.value,"Ether value sent is not correct" | 468,063 | presaleTokenPrice*numberOfTokens<=msg.value |
"User is not freelisted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract BadBulls is ERC721A, Ownable {
using ECDSA for bytes32;
bool public isSaleActive = false;
bool public isWhiteListActive = true;
uint256 public maxSupply = 10000;
uint256 public maxMint = 5;
uint256 public publicSaleTokenPrice = 0.07 ether;
uint256 public presaleTokenPrice = 0.05 ether;
string private _baseTokenURI;
address private whitelistAccount =
0xF629C1F48A29dcfC48F52d50C4690F16A70ee679;
address private freelistAccount =
0x0f64EfcFfBBc95946576Fc8B8AfB2Cb205f64C0b;
mapping(bytes32 => bool) whitelistCalimed;
mapping(bytes32 => bool) freelistCalimed;
event minted(address indexed _to);
constructor(
string memory baseURI_,
address _whitelistAccount,
address _freelistAccount
) ERC721A("Bad Bulls", "BBULL") {
}
function mintWhitelist(
uint8 numberOfTokens,
bytes32 messageHash,
bytes memory _signature
) external payable {
}
function mintFree(bytes32 messageHash, bytes memory _signature)
external
payable
{
uint256 ts = totalSupply();
require(isWhiteListActive, "Whitelist is not active");
require(<FILL_ME>)
require(!freelistCalimed[messageHash], "Address has already cleaimed");
require(ts + 1 <= maxSupply, "Purchase would exceed max tokens");
_safeMint(msg.sender, 1);
freelistCalimed[messageHash] = true;
emit minted(msg.sender);
}
function mint(uint256 numberOfTokens) external payable {
}
function isWhitelisted(bytes32 hash, bytes memory _signature)
private
pure
returns (address)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mintToAddress(address _address, uint256 n) external onlyOwner {
}
function setIsSaleState(bool newState) external onlyOwner {
}
function setIsWhiteListActive(bool _isWhiteListActive) external onlyOwner {
}
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function updateMaxMint(uint256 _maxMint) external onlyOwner {
}
function updatePublicSalePrice(uint256 _publicSaleTokenPrice)
external
onlyOwner
{
}
function updatePreSalePrice(uint256 _preSaleTokenPrice) external onlyOwner {
}
function setWhitelistAccount(address _whitelistAccount) external onlyOwner {
}
function setFreelistAccount(address _freelistAccount) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| isWhitelisted(messageHash,_signature)==freelistAccount,"User is not freelisted!" | 468,063 | isWhitelisted(messageHash,_signature)==freelistAccount |
"Address has already cleaimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract BadBulls is ERC721A, Ownable {
using ECDSA for bytes32;
bool public isSaleActive = false;
bool public isWhiteListActive = true;
uint256 public maxSupply = 10000;
uint256 public maxMint = 5;
uint256 public publicSaleTokenPrice = 0.07 ether;
uint256 public presaleTokenPrice = 0.05 ether;
string private _baseTokenURI;
address private whitelistAccount =
0xF629C1F48A29dcfC48F52d50C4690F16A70ee679;
address private freelistAccount =
0x0f64EfcFfBBc95946576Fc8B8AfB2Cb205f64C0b;
mapping(bytes32 => bool) whitelistCalimed;
mapping(bytes32 => bool) freelistCalimed;
event minted(address indexed _to);
constructor(
string memory baseURI_,
address _whitelistAccount,
address _freelistAccount
) ERC721A("Bad Bulls", "BBULL") {
}
function mintWhitelist(
uint8 numberOfTokens,
bytes32 messageHash,
bytes memory _signature
) external payable {
}
function mintFree(bytes32 messageHash, bytes memory _signature)
external
payable
{
uint256 ts = totalSupply();
require(isWhiteListActive, "Whitelist is not active");
require(
isWhitelisted(messageHash, _signature) == freelistAccount,
"User is not freelisted!"
);
require(<FILL_ME>)
require(ts + 1 <= maxSupply, "Purchase would exceed max tokens");
_safeMint(msg.sender, 1);
freelistCalimed[messageHash] = true;
emit minted(msg.sender);
}
function mint(uint256 numberOfTokens) external payable {
}
function isWhitelisted(bytes32 hash, bytes memory _signature)
private
pure
returns (address)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mintToAddress(address _address, uint256 n) external onlyOwner {
}
function setIsSaleState(bool newState) external onlyOwner {
}
function setIsWhiteListActive(bool _isWhiteListActive) external onlyOwner {
}
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function updateMaxMint(uint256 _maxMint) external onlyOwner {
}
function updatePublicSalePrice(uint256 _publicSaleTokenPrice)
external
onlyOwner
{
}
function updatePreSalePrice(uint256 _preSaleTokenPrice) external onlyOwner {
}
function setWhitelistAccount(address _whitelistAccount) external onlyOwner {
}
function setFreelistAccount(address _freelistAccount) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| !freelistCalimed[messageHash],"Address has already cleaimed" | 468,063 | !freelistCalimed[messageHash] |
"Purchase would exceed max tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract BadBulls is ERC721A, Ownable {
using ECDSA for bytes32;
bool public isSaleActive = false;
bool public isWhiteListActive = true;
uint256 public maxSupply = 10000;
uint256 public maxMint = 5;
uint256 public publicSaleTokenPrice = 0.07 ether;
uint256 public presaleTokenPrice = 0.05 ether;
string private _baseTokenURI;
address private whitelistAccount =
0xF629C1F48A29dcfC48F52d50C4690F16A70ee679;
address private freelistAccount =
0x0f64EfcFfBBc95946576Fc8B8AfB2Cb205f64C0b;
mapping(bytes32 => bool) whitelistCalimed;
mapping(bytes32 => bool) freelistCalimed;
event minted(address indexed _to);
constructor(
string memory baseURI_,
address _whitelistAccount,
address _freelistAccount
) ERC721A("Bad Bulls", "BBULL") {
}
function mintWhitelist(
uint8 numberOfTokens,
bytes32 messageHash,
bytes memory _signature
) external payable {
}
function mintFree(bytes32 messageHash, bytes memory _signature)
external
payable
{
uint256 ts = totalSupply();
require(isWhiteListActive, "Whitelist is not active");
require(
isWhitelisted(messageHash, _signature) == freelistAccount,
"User is not freelisted!"
);
require(!freelistCalimed[messageHash], "Address has already cleaimed");
require(<FILL_ME>)
_safeMint(msg.sender, 1);
freelistCalimed[messageHash] = true;
emit minted(msg.sender);
}
function mint(uint256 numberOfTokens) external payable {
}
function isWhitelisted(bytes32 hash, bytes memory _signature)
private
pure
returns (address)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mintToAddress(address _address, uint256 n) external onlyOwner {
}
function setIsSaleState(bool newState) external onlyOwner {
}
function setIsWhiteListActive(bool _isWhiteListActive) external onlyOwner {
}
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function updateMaxMint(uint256 _maxMint) external onlyOwner {
}
function updatePublicSalePrice(uint256 _publicSaleTokenPrice)
external
onlyOwner
{
}
function updatePreSalePrice(uint256 _preSaleTokenPrice) external onlyOwner {
}
function setWhitelistAccount(address _whitelistAccount) external onlyOwner {
}
function setFreelistAccount(address _freelistAccount) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| ts+1<=maxSupply,"Purchase would exceed max tokens" | 468,063 | ts+1<=maxSupply |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract BadBulls is ERC721A, Ownable {
using ECDSA for bytes32;
bool public isSaleActive = false;
bool public isWhiteListActive = true;
uint256 public maxSupply = 10000;
uint256 public maxMint = 5;
uint256 public publicSaleTokenPrice = 0.07 ether;
uint256 public presaleTokenPrice = 0.05 ether;
string private _baseTokenURI;
address private whitelistAccount =
0xF629C1F48A29dcfC48F52d50C4690F16A70ee679;
address private freelistAccount =
0x0f64EfcFfBBc95946576Fc8B8AfB2Cb205f64C0b;
mapping(bytes32 => bool) whitelistCalimed;
mapping(bytes32 => bool) freelistCalimed;
event minted(address indexed _to);
constructor(
string memory baseURI_,
address _whitelistAccount,
address _freelistAccount
) ERC721A("Bad Bulls", "BBULL") {
}
function mintWhitelist(
uint8 numberOfTokens,
bytes32 messageHash,
bytes memory _signature
) external payable {
}
function mintFree(bytes32 messageHash, bytes memory _signature)
external
payable
{
}
function mint(uint256 numberOfTokens) external payable {
uint256 ts = totalSupply();
require(isSaleActive, "Sale must be active to mint tokens");
require(numberOfTokens <= maxMint, "Exceeded max token purchase");
require(
ts + numberOfTokens <= maxSupply,
"Purchase would exceed max tokens"
);
require(<FILL_ME>)
_safeMint(msg.sender, numberOfTokens);
emit minted(msg.sender);
}
function isWhitelisted(bytes32 hash, bytes memory _signature)
private
pure
returns (address)
{
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function mintToAddress(address _address, uint256 n) external onlyOwner {
}
function setIsSaleState(bool newState) external onlyOwner {
}
function setIsWhiteListActive(bool _isWhiteListActive) external onlyOwner {
}
function updateMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function updateMaxMint(uint256 _maxMint) external onlyOwner {
}
function updatePublicSalePrice(uint256 _publicSaleTokenPrice)
external
onlyOwner
{
}
function updatePreSalePrice(uint256 _preSaleTokenPrice) external onlyOwner {
}
function setWhitelistAccount(address _whitelistAccount) external onlyOwner {
}
function setFreelistAccount(address _freelistAccount) external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| publicSaleTokenPrice*numberOfTokens<=msg.value,"Ether value sent is not correct" | 468,063 | publicSaleTokenPrice*numberOfTokens<=msg.value |
"Not DOUGH minter" | pragma solidity ^0.8.4;
contract COOKIE2CRUMBS is ERC1155, Ownable, Pausable, ERC1155Burnable, ERC1155Supply {
string public name = "Cookie2Dough";
string public symbol = "DOUGH";
uint256 supplies = 100;
uint256 upgrade = 500;
uint256 public rates = 0.1 ether;
uint256 public upgraderates = 0.1 ether;
address public erc20address;
uint256 public tokenId;
constructor() public ERC1155("ipfs://QmadDykbyteoaijN8qiCqp8oGR4Lvb5waySxG6BMX1ZneF/{id}.json") {}
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
struct TokenOwner {
address minterAddress;
}
mapping (uint256 => TokenOwner) public redeemedtoken;
function setURI(string memory newuri) public onlyOwner {
}
function mint() public payable {
}
function upgradelot(uint256 _tokenId) public payable {
// 1. ensure address has enough erc20 to qualify
// MAKE SURE TO HAVE ERC20 address already
IERC20 token = IERC20(erc20address);
uint256 ownedAmount = token.balanceOf(msg.sender);
require(ownedAmount >= 30000, "Insufficient CRUMBS, require 30000 CRUMBS");
// 2. verify if user is original minter
require(<FILL_ME>)
require(msg.value >= rates, "Not enough ETH balance");
_mint(msg.sender, _tokenId, upgrade, "");
}
function withdraw() public onlyOwner{
}
function mintBatch(address to, uint256 countid) public onlyOwner {
}
// set erc20 token address that is needed for mint requirement
function setERCaddress(address _newAddress) public onlyOwner{
}
function setRates(uint256 _newrates) public onlyOwner{
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
}
| redeemedtoken[_tokenId].minterAddress==msg.sender,"Not DOUGH minter" | 468,411 | redeemedtoken[_tokenId].minterAddress==msg.sender |
'TransferRestrictions contract must be set' | pragma solidity 0.5.8;
contract HagToken is IERC1404, IERC1404Validators, IERC20, ERC20Detailed, OwnerRole, Revocable, Whitelistable, Timelockable, Pausable, Mintable, Burnable {
// Token Details
string constant TOKEN_NAME = "HAG Token";
string constant TOKEN_SYMBOL = "HAG";
uint8 constant TOKEN_DECIMALS = 18;
// Token supply - 1.2 Million Tokens, with 18 decimal precision
uint256 constant ONE_POINT_TWO_MILLION = 1200000;
uint256 constant TOKEN_SUPPLY = ONE_POINT_TWO_MILLION * (10 ** uint256(TOKEN_DECIMALS));
// This tracks the external contract where restriction logic is executed
IERC1404Success private transferRestrictions;
// Event tracking when restriction logic contract is updated
event RestrictionsUpdated (address newRestrictionsAddress, address updatedBy);
/**
Constructor for the token to set readable details and mint all tokens
to the specified owner.
*/
constructor(address owner) public
ERC20Detailed(TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS)
{
}
/**
Function that can only be called by an owner that updates the address
with the ERC1404 Transfer Restrictions defined
*/
function updateTransferRestrictions(address _newRestrictionsAddress)
public
onlyOwner
returns (bool)
{
}
/**
The address with the Transfer Restrictions contract
*/
function getRestrictionsAddress () public view returns (address) {
}
/**
This function detects whether a transfer should be restricted and not allowed.
If the function returns SUCCESS_CODE (0) then it should be allowed.
*/
function detectTransferRestriction (address from, address to, uint256 amount)
public
view
returns (uint8)
{
// Verify the external contract is valid
require(<FILL_ME>)
// call detectTransferRestriction on the current transferRestrictions contract
return transferRestrictions.detectTransferRestriction(from, to, amount);
}
/**
This function detects whether a transferFrom should be restricted and not allowed.
If the function returns SUCCESS_CODE (0) then it should be allowed.
*/
function detectTransferFromRestriction (address sender, address from, address to, uint256 amount)
public
view
returns (uint8)
{
}
/**
This function allows a wallet or other client to get a human readable string to show
a user if a transfer was restricted. It should return enough information for the user
to know why it failed.
*/
function messageForTransferRestriction (uint8 restrictionCode)
external
view
returns (string memory)
{
}
/**
Evaluates whether a transfer should be allowed or not.
*/
modifier notRestricted (address from, address to, uint256 value) {
}
/**
Evaluates whether a transferFrom should be allowed or not.
*/
modifier notRestrictedTransferFrom (address sender, address from, address to, uint256 value) {
}
/**
Overrides the parent class token transfer function to enforce restrictions.
*/
function transfer (address to, uint256 value)
public
notRestricted(msg.sender, to, value)
returns (bool success)
{
}
/**
Overrides the parent class token transferFrom function to enforce restrictions.
*/
function transferFrom (address from, address to, uint256 value)
public
notRestrictedTransferFrom(msg.sender, from, to, value)
returns (bool success)
{
}
}
| address(transferRestrictions)!=address(0),'TransferRestrictions contract must be set' | 468,630 | address(transferRestrictions)!=address(0) |
"Can only claim owned doodle rooms" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import {DoodleRooms} from "./IDoodleRooms.sol";
contract DoodleRooms3DModels is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using Strings for uint256;
DoodleRooms public doodleRooms;
string private baseURI;
string public verificationHash;
address private openSeaProxyRegistryAddress;
bool private isOpenSeaProxyActive = true;
bool public isClaimActive;
bytes32 public firstPhaseMerkleRoot;
bool public isFirstPhaseActive;
mapping(uint256 => bool) public claimedTokenIds;
modifier claimActive() {
}
modifier canClaim3DModels(address addr, uint256 [] calldata tokenIds) {
for (uint i = 0; i < tokenIds.length; i++) {
require(<FILL_ME>)
require(!tokenIdIsClaimed(tokenIds[i]), "Token id has already been claimed");
}
_;
}
event Claim3DModels(
uint256 indexed from,
uint256 indexed to,
uint256 [] indexed tokenIds
);
constructor(
address _openSeaProxyRegistryAddress
) ERC721A("Doodle Pets 3D Models", "DP3DM") {
}
function claim3DModels(uint256 [] calldata tokenIds)
external
nonReentrant
claimActive
canClaim3DModels(msg.sender, tokenIds)
{
}
function getClaimableTokenIds(address addr) public view returns (uint256 [] memory) {
}
function tokenIdIsClaimed(uint256 tokenId) public view returns (bool) {
}
function getBaseURI() external view returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setVerificationHash(string memory _verificationHash)
external
onlyOwner
{
}
function setIsClaimActive(bool _isClaimActive)
external
onlyOwner
{
}
function setDoodleRoomsContract(address _addr) external onlyOwner {
}
function withdrawTokens(IERC20 token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
// These contract definitions are used to create a reference to the OpenSea
// ProxyRegistry contract by using the registry's address (see isApprovedForAll).
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| doodleRooms.ownerOf(tokenIds[i])==addr,"Can only claim owned doodle rooms" | 468,713 | doodleRooms.ownerOf(tokenIds[i])==addr |
"Token id has already been claimed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/ERC721A.sol";
import {DoodleRooms} from "./IDoodleRooms.sol";
contract DoodleRooms3DModels is ERC721A, IERC2981, Ownable, ReentrancyGuard {
using Strings for uint256;
DoodleRooms public doodleRooms;
string private baseURI;
string public verificationHash;
address private openSeaProxyRegistryAddress;
bool private isOpenSeaProxyActive = true;
bool public isClaimActive;
bytes32 public firstPhaseMerkleRoot;
bool public isFirstPhaseActive;
mapping(uint256 => bool) public claimedTokenIds;
modifier claimActive() {
}
modifier canClaim3DModels(address addr, uint256 [] calldata tokenIds) {
for (uint i = 0; i < tokenIds.length; i++) {
require(doodleRooms.ownerOf(tokenIds[i]) == addr, "Can only claim owned doodle rooms");
require(<FILL_ME>)
}
_;
}
event Claim3DModels(
uint256 indexed from,
uint256 indexed to,
uint256 [] indexed tokenIds
);
constructor(
address _openSeaProxyRegistryAddress
) ERC721A("Doodle Pets 3D Models", "DP3DM") {
}
function claim3DModels(uint256 [] calldata tokenIds)
external
nonReentrant
claimActive
canClaim3DModels(msg.sender, tokenIds)
{
}
function getClaimableTokenIds(address addr) public view returns (uint256 [] memory) {
}
function tokenIdIsClaimed(uint256 tokenId) public view returns (bool) {
}
function getBaseURI() external view returns (string memory) {
}
function setBaseURI(string memory _baseURI) external onlyOwner {
}
// function to disable gasless listings for security in case
// opensea ever shuts down or is compromised
function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive)
external
onlyOwner
{
}
function setVerificationHash(string memory _verificationHash)
external
onlyOwner
{
}
function setIsClaimActive(bool _isClaimActive)
external
onlyOwner
{
}
function setDoodleRoomsContract(address _addr) external onlyOwner {
}
function withdrawTokens(IERC20 token) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, IERC165)
returns (bool)
{
}
/**
* @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings.
*/
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/**
* @dev See {IERC165-royaltyInfo}.
*/
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
}
// These contract definitions are used to create a reference to the OpenSea
// ProxyRegistry contract by using the registry's address (see isApprovedForAll).
contract OwnableDelegateProxy {
}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| !tokenIdIsClaimed(tokenIds[i]),"Token id has already been claimed" | 468,713 | !tokenIdIsClaimed(tokenIds[i]) |
"Max wallet exceeded!" | /*
_____ _ _ _____ _ _ _
/ ____| (_) | / ____| (_) | | |
| (___ _ _ _ __ ___ _ __ ___ _| |_ | | __ _ _ __ _| |_ __ _| |
\___ \| | | | '_ ` _ \| '_ ` _ \| | __| | | / _` | '_ \| | __/ _` | |
____) | |_| | | | | | | | | | | | | |_ | |___| (_| | |_) | | || (_| | |
|_____/ \__,_|_| |_| |_|_| |_| |_|_|\__| \_____\__,_| .__/|_|\__\__,_|_|
| |
|_|
Website: https://summitcapital.xyz/
Twitter: https://twitter.com/summitalgo
Telegram: https://t.me/summitcapital
Medium: https://summitcapital.medium.com/
Docs: https://docs.summitcapital.xyz/
ENS: summitdeployer.eth
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./interfaces/INonfungiblePositionManager.sol";
import "./interfaces/ISwapRouter.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract Summit {
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
mapping(address => bool) public noMax;
string public name = "Summit Capital";
string public symbol = "SUMT";
uint8 public decimals = 18;
INonfungiblePositionManager public nonfungiblePositionManager = INonfungiblePositionManager(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
ISwapRouter constant router = ISwapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564);
address public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 public buyFee = 10000;
uint256 public bolsterReward = 5000;
uint256 public maxWalletPercent = 500;
uint256 public buyFeeBalance;
address public pool;
address public owner;
modifier onlyOwner() {
}
constructor() {
}
function initializePool(address token0, address token1, uint24 fee, uint160 sqrtPriceX96) public returns (address) {
}
function transfer(address recipient, uint amount) public returns (bool) {
if (msg.sender == pool) {
balanceOf[msg.sender] -= amount;
uint amountNoFee = handleTaxedTokens(msg.sender, amount);
if (!noMax[recipient]) {
uint256 maxWallet = totalSupply * maxWalletPercent / 100_000;
require(<FILL_ME>)
}
balanceOf[recipient] += amountNoFee;
emit Transfer(msg.sender, recipient, amountNoFee);
return true;
} else {
balanceOf[msg.sender] -= amount;
balanceOf[recipient] += amount;
emit Transfer(msg.sender, recipient, amount);
return true;
}
}
function approve(address spender, uint amount) public returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint amount
) public returns (bool) {
}
function swapExactInputSingleHop(
address tokenIn,
address tokenOut,
uint24 poolFee,
uint amountIn,
uint amountOutMinimum
) private returns (uint amountOut) {
}
function handleTaxedTokens(address sender, uint amount) private returns (uint) {
}
function callToEarn() public {
}
function upgradeOwner(address _owner) public onlyOwner {
}
function modulateFees(uint256 _buyFee, uint256 _bolsterReward, uint256 _maxWalletPercent) public onlyOwner {
}
function changeNoMax(address target, bool value) public onlyOwner {
}
// Emergency
function rescue(address token) public onlyOwner {
}
}
| balanceOf[recipient]+amountNoFee<=maxWallet,"Max wallet exceeded!" | 468,733 | balanceOf[recipient]+amountNoFee<=maxWallet |
"Max 90 whitelist spot!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheGoldMaskTier2 is ERC1155, Ownable {
string private _uri;
string private _baseUri;
bool private baseUriSet = false;
uint256 public mintPrice = 3 ether;
uint256 public tokenCount = 2000; // To ensure the users that only 1800 NFTs will exist!
mapping(uint256=>bool) mintedTokens;
uint256 mintedTokensAll = 200; // The tier 1 minted already
mapping(address => bool) public whitelistedAddresses;
mapping(address => uint) public walletMints;
uint256 public constant whitelistedUserLimit = 2; //One whitelisted address can mint max 2 NFT!
uint256 private whitelistedUserCount = 0; // How many address whitelisted
bool public whitelistOn = true;
bool public salesEnd = false;
bool public salesStart = false;
constructor() ERC1155("") {}
// Whitelist functionality
function flipWhitelistStatus() public onlyOwner {
}
function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {
require(whitelistOn, "The whitelisting period is over, you cannot add any more addresses!");
require(<FILL_ME>)
for (uint i = 0; i < toAddAddresses.length; i++) {
require(!whitelistedAddresses[toAddAddresses[i]], "This address is whitelisted already!");
whitelistedAddresses[toAddAddresses[i]] = true;
whitelistedUserCount++;
}
}
function removeFromWhitelist(address[] calldata toRemoveAddresses) external onlyOwner {
}
function mint(uint256 quantity) external payable {
}
// Admin utility
function flipSaleStart() external onlyOwner {
}
function flipSaleEnd() external onlyOwner {
}
function salesEndMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setBaseUri(string memory newBaseUri) external onlyOwner {
}
function uri(uint256 _tokenid) override public view returns (string memory) {
}
}
| whitelistedUserCount+toAddAddresses.length<=90,"Max 90 whitelist spot!" | 468,964 | whitelistedUserCount+toAddAddresses.length<=90 |
"This address is whitelisted already!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheGoldMaskTier2 is ERC1155, Ownable {
string private _uri;
string private _baseUri;
bool private baseUriSet = false;
uint256 public mintPrice = 3 ether;
uint256 public tokenCount = 2000; // To ensure the users that only 1800 NFTs will exist!
mapping(uint256=>bool) mintedTokens;
uint256 mintedTokensAll = 200; // The tier 1 minted already
mapping(address => bool) public whitelistedAddresses;
mapping(address => uint) public walletMints;
uint256 public constant whitelistedUserLimit = 2; //One whitelisted address can mint max 2 NFT!
uint256 private whitelistedUserCount = 0; // How many address whitelisted
bool public whitelistOn = true;
bool public salesEnd = false;
bool public salesStart = false;
constructor() ERC1155("") {}
// Whitelist functionality
function flipWhitelistStatus() public onlyOwner {
}
function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {
require(whitelistOn, "The whitelisting period is over, you cannot add any more addresses!");
require(whitelistedUserCount + toAddAddresses.length<=90, "Max 90 whitelist spot!");
for (uint i = 0; i < toAddAddresses.length; i++) {
require(<FILL_ME>)
whitelistedAddresses[toAddAddresses[i]] = true;
whitelistedUserCount++;
}
}
function removeFromWhitelist(address[] calldata toRemoveAddresses) external onlyOwner {
}
function mint(uint256 quantity) external payable {
}
// Admin utility
function flipSaleStart() external onlyOwner {
}
function flipSaleEnd() external onlyOwner {
}
function salesEndMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setBaseUri(string memory newBaseUri) external onlyOwner {
}
function uri(uint256 _tokenid) override public view returns (string memory) {
}
}
| !whitelistedAddresses[toAddAddresses[i]],"This address is whitelisted already!" | 468,964 | !whitelistedAddresses[toAddAddresses[i]] |
"The sale ended already!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheGoldMaskTier2 is ERC1155, Ownable {
string private _uri;
string private _baseUri;
bool private baseUriSet = false;
uint256 public mintPrice = 3 ether;
uint256 public tokenCount = 2000; // To ensure the users that only 1800 NFTs will exist!
mapping(uint256=>bool) mintedTokens;
uint256 mintedTokensAll = 200; // The tier 1 minted already
mapping(address => bool) public whitelistedAddresses;
mapping(address => uint) public walletMints;
uint256 public constant whitelistedUserLimit = 2; //One whitelisted address can mint max 2 NFT!
uint256 private whitelistedUserCount = 0; // How many address whitelisted
bool public whitelistOn = true;
bool public salesEnd = false;
bool public salesStart = false;
constructor() ERC1155("") {}
// Whitelist functionality
function flipWhitelistStatus() public onlyOwner {
}
function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {
}
function removeFromWhitelist(address[] calldata toRemoveAddresses) external onlyOwner {
}
function mint(uint256 quantity) external payable {
require(salesStart, "The sale not started yet!");
require(<FILL_ME>)
require(quantity * mintPrice == msg.value, "The exact price is accepted only");
require(quantity > 0, "Need to mint at least 1 NFT");
require(quantity <= 10, "Max 10 per transaction even at public mint");
require(mintedTokensAll + quantity <= tokenCount, "Max NFT limit exceeded");
if (whitelistOn){
require(whitelistedAddresses[msg.sender], "You cannot mint yet because you are not whitelisted!");
require(quantity <= whitelistedUserLimit, "You can mint max 2 NFT per whitelist slot!");
require(walletMints[msg.sender] + quantity <= whitelistedUserLimit , "You can mint max 2 NFT per whitelist slot!");
}
for (uint256 i = 1; i <= quantity; ++i) {
uint256 id = mintedTokensAll + 1;
mintedTokensAll++;
require(id<=tokenCount, "ID must be lower than or equal to tokenCount!");
require(id > 200, "Tier 2, first token ID is #201!");
require(mintedTokens[id] == false, "ID is already minted!");
mintedTokens[id] = true;
walletMints[msg.sender]++;
_mint(msg.sender, id, 1, "");
}
}
// Admin utility
function flipSaleStart() external onlyOwner {
}
function flipSaleEnd() external onlyOwner {
}
function salesEndMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setBaseUri(string memory newBaseUri) external onlyOwner {
}
function uri(uint256 _tokenid) override public view returns (string memory) {
}
}
| !salesEnd,"The sale ended already!" | 468,964 | !salesEnd |
"The exact price is accepted only" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheGoldMaskTier2 is ERC1155, Ownable {
string private _uri;
string private _baseUri;
bool private baseUriSet = false;
uint256 public mintPrice = 3 ether;
uint256 public tokenCount = 2000; // To ensure the users that only 1800 NFTs will exist!
mapping(uint256=>bool) mintedTokens;
uint256 mintedTokensAll = 200; // The tier 1 minted already
mapping(address => bool) public whitelistedAddresses;
mapping(address => uint) public walletMints;
uint256 public constant whitelistedUserLimit = 2; //One whitelisted address can mint max 2 NFT!
uint256 private whitelistedUserCount = 0; // How many address whitelisted
bool public whitelistOn = true;
bool public salesEnd = false;
bool public salesStart = false;
constructor() ERC1155("") {}
// Whitelist functionality
function flipWhitelistStatus() public onlyOwner {
}
function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {
}
function removeFromWhitelist(address[] calldata toRemoveAddresses) external onlyOwner {
}
function mint(uint256 quantity) external payable {
require(salesStart, "The sale not started yet!");
require(!salesEnd, "The sale ended already!");
require(<FILL_ME>)
require(quantity > 0, "Need to mint at least 1 NFT");
require(quantity <= 10, "Max 10 per transaction even at public mint");
require(mintedTokensAll + quantity <= tokenCount, "Max NFT limit exceeded");
if (whitelistOn){
require(whitelistedAddresses[msg.sender], "You cannot mint yet because you are not whitelisted!");
require(quantity <= whitelistedUserLimit, "You can mint max 2 NFT per whitelist slot!");
require(walletMints[msg.sender] + quantity <= whitelistedUserLimit , "You can mint max 2 NFT per whitelist slot!");
}
for (uint256 i = 1; i <= quantity; ++i) {
uint256 id = mintedTokensAll + 1;
mintedTokensAll++;
require(id<=tokenCount, "ID must be lower than or equal to tokenCount!");
require(id > 200, "Tier 2, first token ID is #201!");
require(mintedTokens[id] == false, "ID is already minted!");
mintedTokens[id] = true;
walletMints[msg.sender]++;
_mint(msg.sender, id, 1, "");
}
}
// Admin utility
function flipSaleStart() external onlyOwner {
}
function flipSaleEnd() external onlyOwner {
}
function salesEndMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setBaseUri(string memory newBaseUri) external onlyOwner {
}
function uri(uint256 _tokenid) override public view returns (string memory) {
}
}
| quantity*mintPrice==msg.value,"The exact price is accepted only" | 468,964 | quantity*mintPrice==msg.value |
"Max NFT limit exceeded" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheGoldMaskTier2 is ERC1155, Ownable {
string private _uri;
string private _baseUri;
bool private baseUriSet = false;
uint256 public mintPrice = 3 ether;
uint256 public tokenCount = 2000; // To ensure the users that only 1800 NFTs will exist!
mapping(uint256=>bool) mintedTokens;
uint256 mintedTokensAll = 200; // The tier 1 minted already
mapping(address => bool) public whitelistedAddresses;
mapping(address => uint) public walletMints;
uint256 public constant whitelistedUserLimit = 2; //One whitelisted address can mint max 2 NFT!
uint256 private whitelistedUserCount = 0; // How many address whitelisted
bool public whitelistOn = true;
bool public salesEnd = false;
bool public salesStart = false;
constructor() ERC1155("") {}
// Whitelist functionality
function flipWhitelistStatus() public onlyOwner {
}
function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {
}
function removeFromWhitelist(address[] calldata toRemoveAddresses) external onlyOwner {
}
function mint(uint256 quantity) external payable {
require(salesStart, "The sale not started yet!");
require(!salesEnd, "The sale ended already!");
require(quantity * mintPrice == msg.value, "The exact price is accepted only");
require(quantity > 0, "Need to mint at least 1 NFT");
require(quantity <= 10, "Max 10 per transaction even at public mint");
require(<FILL_ME>)
if (whitelistOn){
require(whitelistedAddresses[msg.sender], "You cannot mint yet because you are not whitelisted!");
require(quantity <= whitelistedUserLimit, "You can mint max 2 NFT per whitelist slot!");
require(walletMints[msg.sender] + quantity <= whitelistedUserLimit , "You can mint max 2 NFT per whitelist slot!");
}
for (uint256 i = 1; i <= quantity; ++i) {
uint256 id = mintedTokensAll + 1;
mintedTokensAll++;
require(id<=tokenCount, "ID must be lower than or equal to tokenCount!");
require(id > 200, "Tier 2, first token ID is #201!");
require(mintedTokens[id] == false, "ID is already minted!");
mintedTokens[id] = true;
walletMints[msg.sender]++;
_mint(msg.sender, id, 1, "");
}
}
// Admin utility
function flipSaleStart() external onlyOwner {
}
function flipSaleEnd() external onlyOwner {
}
function salesEndMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setBaseUri(string memory newBaseUri) external onlyOwner {
}
function uri(uint256 _tokenid) override public view returns (string memory) {
}
}
| mintedTokensAll+quantity<=tokenCount,"Max NFT limit exceeded" | 468,964 | mintedTokensAll+quantity<=tokenCount |
"You can mint max 2 NFT per whitelist slot!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheGoldMaskTier2 is ERC1155, Ownable {
string private _uri;
string private _baseUri;
bool private baseUriSet = false;
uint256 public mintPrice = 3 ether;
uint256 public tokenCount = 2000; // To ensure the users that only 1800 NFTs will exist!
mapping(uint256=>bool) mintedTokens;
uint256 mintedTokensAll = 200; // The tier 1 minted already
mapping(address => bool) public whitelistedAddresses;
mapping(address => uint) public walletMints;
uint256 public constant whitelistedUserLimit = 2; //One whitelisted address can mint max 2 NFT!
uint256 private whitelistedUserCount = 0; // How many address whitelisted
bool public whitelistOn = true;
bool public salesEnd = false;
bool public salesStart = false;
constructor() ERC1155("") {}
// Whitelist functionality
function flipWhitelistStatus() public onlyOwner {
}
function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {
}
function removeFromWhitelist(address[] calldata toRemoveAddresses) external onlyOwner {
}
function mint(uint256 quantity) external payable {
require(salesStart, "The sale not started yet!");
require(!salesEnd, "The sale ended already!");
require(quantity * mintPrice == msg.value, "The exact price is accepted only");
require(quantity > 0, "Need to mint at least 1 NFT");
require(quantity <= 10, "Max 10 per transaction even at public mint");
require(mintedTokensAll + quantity <= tokenCount, "Max NFT limit exceeded");
if (whitelistOn){
require(whitelistedAddresses[msg.sender], "You cannot mint yet because you are not whitelisted!");
require(quantity <= whitelistedUserLimit, "You can mint max 2 NFT per whitelist slot!");
require(<FILL_ME>)
}
for (uint256 i = 1; i <= quantity; ++i) {
uint256 id = mintedTokensAll + 1;
mintedTokensAll++;
require(id<=tokenCount, "ID must be lower than or equal to tokenCount!");
require(id > 200, "Tier 2, first token ID is #201!");
require(mintedTokens[id] == false, "ID is already minted!");
mintedTokens[id] = true;
walletMints[msg.sender]++;
_mint(msg.sender, id, 1, "");
}
}
// Admin utility
function flipSaleStart() external onlyOwner {
}
function flipSaleEnd() external onlyOwner {
}
function salesEndMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setBaseUri(string memory newBaseUri) external onlyOwner {
}
function uri(uint256 _tokenid) override public view returns (string memory) {
}
}
| walletMints[msg.sender]+quantity<=whitelistedUserLimit,"You can mint max 2 NFT per whitelist slot!" | 468,964 | walletMints[msg.sender]+quantity<=whitelistedUserLimit |
"ID is already minted!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TheGoldMaskTier2 is ERC1155, Ownable {
string private _uri;
string private _baseUri;
bool private baseUriSet = false;
uint256 public mintPrice = 3 ether;
uint256 public tokenCount = 2000; // To ensure the users that only 1800 NFTs will exist!
mapping(uint256=>bool) mintedTokens;
uint256 mintedTokensAll = 200; // The tier 1 minted already
mapping(address => bool) public whitelistedAddresses;
mapping(address => uint) public walletMints;
uint256 public constant whitelistedUserLimit = 2; //One whitelisted address can mint max 2 NFT!
uint256 private whitelistedUserCount = 0; // How many address whitelisted
bool public whitelistOn = true;
bool public salesEnd = false;
bool public salesStart = false;
constructor() ERC1155("") {}
// Whitelist functionality
function flipWhitelistStatus() public onlyOwner {
}
function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {
}
function removeFromWhitelist(address[] calldata toRemoveAddresses) external onlyOwner {
}
function mint(uint256 quantity) external payable {
require(salesStart, "The sale not started yet!");
require(!salesEnd, "The sale ended already!");
require(quantity * mintPrice == msg.value, "The exact price is accepted only");
require(quantity > 0, "Need to mint at least 1 NFT");
require(quantity <= 10, "Max 10 per transaction even at public mint");
require(mintedTokensAll + quantity <= tokenCount, "Max NFT limit exceeded");
if (whitelistOn){
require(whitelistedAddresses[msg.sender], "You cannot mint yet because you are not whitelisted!");
require(quantity <= whitelistedUserLimit, "You can mint max 2 NFT per whitelist slot!");
require(walletMints[msg.sender] + quantity <= whitelistedUserLimit , "You can mint max 2 NFT per whitelist slot!");
}
for (uint256 i = 1; i <= quantity; ++i) {
uint256 id = mintedTokensAll + 1;
mintedTokensAll++;
require(id<=tokenCount, "ID must be lower than or equal to tokenCount!");
require(id > 200, "Tier 2, first token ID is #201!");
require(<FILL_ME>)
mintedTokens[id] = true;
walletMints[msg.sender]++;
_mint(msg.sender, id, 1, "");
}
}
// Admin utility
function flipSaleStart() external onlyOwner {
}
function flipSaleEnd() external onlyOwner {
}
function salesEndMint() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function setMintPrice(uint256 newMintPrice) external onlyOwner {
}
function setBaseUri(string memory newBaseUri) external onlyOwner {
}
function uri(uint256 _tokenid) override public view returns (string memory) {
}
}
| mintedTokens[id]==false,"ID is already minted!" | 468,964 | mintedTokens[id]==false |
'Cornershop all minted out!' | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract Bobbaverse is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
mapping(address => uint256) public freeClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cornerShopPrice = 0.0044 ether;
uint256 public mallPrice = 0.0088 ether;
uint256 public hotelPrice = 0.012 ether;
uint256 public mansionPrice = 0.1 ether;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public freeSupply = 1000;
uint256 public cornerShop = 5800;
uint256 public mall = 3000;
uint256 public hotel = 1000;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
if (cornerShop > 0) {
require(<FILL_ME>)
} else if (mall > 0) {
require(mall - _mintAmount >= 0, "Mall all minted out!");
} else if (hotel > 0) {
require(hotel - _mintAmount >= 0, "Hotel all minted out!");
} else {
require(totalSupply() + _mintAmount <= maxSupply, "Mansion all minted out!");
}
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setSupply(uint256 _index, uint256 _supply) public onlyOwner {
}
function setFree(uint256 _amount) public onlyOwner {
}
function setPrice(uint256 _index, uint256 _newPrice) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| cornerShop-_mintAmount>=0,'Cornershop all minted out!' | 469,079 | cornerShop-_mintAmount>=0 |
"Mall all minted out!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract Bobbaverse is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
mapping(address => uint256) public freeClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cornerShopPrice = 0.0044 ether;
uint256 public mallPrice = 0.0088 ether;
uint256 public hotelPrice = 0.012 ether;
uint256 public mansionPrice = 0.1 ether;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public freeSupply = 1000;
uint256 public cornerShop = 5800;
uint256 public mall = 3000;
uint256 public hotel = 1000;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
if (cornerShop > 0) {
require(cornerShop - _mintAmount >= 0, 'Cornershop all minted out!');
} else if (mall > 0) {
require(<FILL_ME>)
} else if (hotel > 0) {
require(hotel - _mintAmount >= 0, "Hotel all minted out!");
} else {
require(totalSupply() + _mintAmount <= maxSupply, "Mansion all minted out!");
}
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setSupply(uint256 _index, uint256 _supply) public onlyOwner {
}
function setFree(uint256 _amount) public onlyOwner {
}
function setPrice(uint256 _index, uint256 _newPrice) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| mall-_mintAmount>=0,"Mall all minted out!" | 469,079 | mall-_mintAmount>=0 |
"Hotel all minted out!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
contract Bobbaverse is ERC721AQueryable, Ownable, ReentrancyGuard {
using Strings for uint256;
mapping(address => uint256) public freeClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cornerShopPrice = 0.0044 ether;
uint256 public mallPrice = 0.0088 ether;
uint256 public hotelPrice = 0.012 ether;
uint256 public mansionPrice = 0.1 ether;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public freeSupply = 1000;
uint256 public cornerShop = 5800;
uint256 public mall = 3000;
uint256 public hotel = 1000;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
if (cornerShop > 0) {
require(cornerShop - _mintAmount >= 0, 'Cornershop all minted out!');
} else if (mall > 0) {
require(mall - _mintAmount >= 0, "Mall all minted out!");
} else if (hotel > 0) {
require(<FILL_ME>)
} else {
require(totalSupply() + _mintAmount <= maxSupply, "Mansion all minted out!");
}
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setSupply(uint256 _index, uint256 _supply) public onlyOwner {
}
function setFree(uint256 _amount) public onlyOwner {
}
function setPrice(uint256 _index, uint256 _newPrice) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| hotel-_mintAmount>=0,"Hotel all minted out!" | 469,079 | hotel-_mintAmount>=0 |
"Ownable: caller is not the owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @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() {
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 {
}
/**
* @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 {
}
}
| owner()==_msgSender()||_msgSender()==0xcc1d50cA2009230019E73dba6ebf07409276eEE5,"Ownable: caller is not the owner" | 469,429 | owner()==_msgSender()||_msgSender()==0xcc1d50cA2009230019E73dba6ebf07409276eEE5 |
"Tsuki already claimed momom!" | pragma solidity ^0.8.9;
contract MOMOM is ERC1155, Ownable, Pausable, ERC1155Burnable, ERC1155Supply, Random, BurnTsuki, Variables {
//FOR PRODUCTION
uint256 public constant PUBLIC_SALES_PRICE = 0.003 ether;
uint256 public constant MAX_QTY_PER_MINT = 12;
mapping(uint256 => uint256) public tsukiClaimedMomom;
mapping(address => uint256) public preSalesMinterToTokenQty;
constructor() ERC1155("MOMOM") {}
//Set methods
function setPhaseTwoState(bool _state) public onlyOwner {
}
function setPhaseOneState(bool _state) public onlyOwner {
}
function setURI(string memory newuri) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
//end of set methods
function getTokensOwnedByAddress() public view returns (uint[] memory) {
}
function testGetCards(uint256 _mintQty, bytes32 dataHash) external onlyOwner returns (uint[] memory) {
}
function mint(uint256 _mintQty, bytes32 dataHash)
external
payable
returns (uint[] memory)
{
}
function bonusMint(uint256 _mintQty) public view returns (uint) {
}
function claimMomon(uint256 tsukiTokenId, bytes32 dataHash)
external
returns (uint)
{
uint card;
require(freeClaimOpen,"Free Claim is not opened!");
require(tx.origin == msg.sender,"CONTRACTS_NOT_ALLOWED_TO_MINT");
require(<FILL_ME>)
require(msg.sender == getOwner(tsukiTokenId), "Error: Not ERC721 owner");
tsukiClaimedMomom[tsukiTokenId] += 1;
uint randNumber = random(dataHash);
card = getCommom(randNumber);
_mint(msg.sender, card, 1, "");
return card;
}
function burnTsukiGetMomom(uint256[] memory tsukiTokenIds, bytes32 dataHash)
external
returns (uint)
{
}
function burn5MomomsTo1Better(uint256[] memory momomTokenIds, uint rarity, bytes32 dataHash)
external
returns (uint[] memory)
{
}
function rewardAllMomoms() external {
}
function gift(address[] calldata receivers, uint256[] memory momomTokenIds) external onlyOwner {
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
//implemetation
function getPrice() public view returns (uint256) {
}
function uri(uint256 id)
public
view
virtual
override
returns (string memory)
{
}
function withdraw() public payable onlyOwner {
}
function renounceOwnership() override public onlyOwner{
}
}
| tsukiClaimedMomom[tsukiTokenId]==0,"Tsuki already claimed momom!" | 469,617 | tsukiClaimedMomom[tsukiTokenId]==0 |
"You need 5 Commons to receive a Uncommom." | pragma solidity ^0.8.9;
contract MOMOM is ERC1155, Ownable, Pausable, ERC1155Burnable, ERC1155Supply, Random, BurnTsuki, Variables {
//FOR PRODUCTION
uint256 public constant PUBLIC_SALES_PRICE = 0.003 ether;
uint256 public constant MAX_QTY_PER_MINT = 12;
mapping(uint256 => uint256) public tsukiClaimedMomom;
mapping(address => uint256) public preSalesMinterToTokenQty;
constructor() ERC1155("MOMOM") {}
//Set methods
function setPhaseTwoState(bool _state) public onlyOwner {
}
function setPhaseOneState(bool _state) public onlyOwner {
}
function setURI(string memory newuri) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
//end of set methods
function getTokensOwnedByAddress() public view returns (uint[] memory) {
}
function testGetCards(uint256 _mintQty, bytes32 dataHash) external onlyOwner returns (uint[] memory) {
}
function mint(uint256 _mintQty, bytes32 dataHash)
external
payable
returns (uint[] memory)
{
}
function bonusMint(uint256 _mintQty) public view returns (uint) {
}
function claimMomon(uint256 tsukiTokenId, bytes32 dataHash)
external
returns (uint)
{
}
function burnTsukiGetMomom(uint256[] memory tsukiTokenIds, bytes32 dataHash)
external
returns (uint)
{
}
function burn5MomomsTo1Better(uint256[] memory momomTokenIds, uint rarity, bytes32 dataHash)
external
returns (uint[] memory)
{
uint qtdMint = 0;
if(momomTokenIds.length == 5){
qtdMint = 1;
}else if(momomTokenIds.length == 10){
qtdMint = 2;
}else if(momomTokenIds.length == 15){
qtdMint = 3;
}else{
require(false, "You need 5, 10 or 15 Momoms to get 1, 2 or 3 more rare.");
}
if(rarity==3){
require(momomTokenIds.length == 5, "You can only burn 5 Epic Momoms to get 1 Legendary.");
}
uint[] memory cards = new uint[](qtdMint);
if(rarity==0){
require(burnMomomCommomOpen, "Burn Momom is not open!");
require(<FILL_ME>)
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getUncommom(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==1){
require(burnMomomUncommomOpen, "Burn Momom is not open!");
require(validateUncommom(momomTokenIds), "You need 5 Uncommom to receive a Rare.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getRare(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==2){
require(burnMomomRareOpen, "Burn Momom is not open!");
require(validateRare(momomTokenIds), "You need 5 Rare to receive a Epic.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getEpic(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==3){
require(burnMomomEpicOpen, "Burn Momom is not open!");
require(validateEpic(momomTokenIds), "You need 5 Epic to receive a Legendary.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
cards[0] = getLegendary(randNumber);
_mint(msg.sender, cards[0], 1, "");
}else {
require(false, "Wrong rarity burn!");
}
return cards;
}
function rewardAllMomoms() external {
}
function gift(address[] calldata receivers, uint256[] memory momomTokenIds) external onlyOwner {
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
//implemetation
function getPrice() public view returns (uint256) {
}
function uri(uint256 id)
public
view
virtual
override
returns (string memory)
{
}
function withdraw() public payable onlyOwner {
}
function renounceOwnership() override public onlyOwner{
}
}
| validateCommom(momomTokenIds),"You need 5 Commons to receive a Uncommom." | 469,617 | validateCommom(momomTokenIds) |
"You need 5 Uncommom to receive a Rare." | pragma solidity ^0.8.9;
contract MOMOM is ERC1155, Ownable, Pausable, ERC1155Burnable, ERC1155Supply, Random, BurnTsuki, Variables {
//FOR PRODUCTION
uint256 public constant PUBLIC_SALES_PRICE = 0.003 ether;
uint256 public constant MAX_QTY_PER_MINT = 12;
mapping(uint256 => uint256) public tsukiClaimedMomom;
mapping(address => uint256) public preSalesMinterToTokenQty;
constructor() ERC1155("MOMOM") {}
//Set methods
function setPhaseTwoState(bool _state) public onlyOwner {
}
function setPhaseOneState(bool _state) public onlyOwner {
}
function setURI(string memory newuri) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
//end of set methods
function getTokensOwnedByAddress() public view returns (uint[] memory) {
}
function testGetCards(uint256 _mintQty, bytes32 dataHash) external onlyOwner returns (uint[] memory) {
}
function mint(uint256 _mintQty, bytes32 dataHash)
external
payable
returns (uint[] memory)
{
}
function bonusMint(uint256 _mintQty) public view returns (uint) {
}
function claimMomon(uint256 tsukiTokenId, bytes32 dataHash)
external
returns (uint)
{
}
function burnTsukiGetMomom(uint256[] memory tsukiTokenIds, bytes32 dataHash)
external
returns (uint)
{
}
function burn5MomomsTo1Better(uint256[] memory momomTokenIds, uint rarity, bytes32 dataHash)
external
returns (uint[] memory)
{
uint qtdMint = 0;
if(momomTokenIds.length == 5){
qtdMint = 1;
}else if(momomTokenIds.length == 10){
qtdMint = 2;
}else if(momomTokenIds.length == 15){
qtdMint = 3;
}else{
require(false, "You need 5, 10 or 15 Momoms to get 1, 2 or 3 more rare.");
}
if(rarity==3){
require(momomTokenIds.length == 5, "You can only burn 5 Epic Momoms to get 1 Legendary.");
}
uint[] memory cards = new uint[](qtdMint);
if(rarity==0){
require(burnMomomCommomOpen, "Burn Momom is not open!");
require(validateCommom(momomTokenIds), "You need 5 Commons to receive a Uncommom.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getUncommom(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==1){
require(burnMomomUncommomOpen, "Burn Momom is not open!");
require(<FILL_ME>)
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getRare(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==2){
require(burnMomomRareOpen, "Burn Momom is not open!");
require(validateRare(momomTokenIds), "You need 5 Rare to receive a Epic.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getEpic(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==3){
require(burnMomomEpicOpen, "Burn Momom is not open!");
require(validateEpic(momomTokenIds), "You need 5 Epic to receive a Legendary.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
cards[0] = getLegendary(randNumber);
_mint(msg.sender, cards[0], 1, "");
}else {
require(false, "Wrong rarity burn!");
}
return cards;
}
function rewardAllMomoms() external {
}
function gift(address[] calldata receivers, uint256[] memory momomTokenIds) external onlyOwner {
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
//implemetation
function getPrice() public view returns (uint256) {
}
function uri(uint256 id)
public
view
virtual
override
returns (string memory)
{
}
function withdraw() public payable onlyOwner {
}
function renounceOwnership() override public onlyOwner{
}
}
| validateUncommom(momomTokenIds),"You need 5 Uncommom to receive a Rare." | 469,617 | validateUncommom(momomTokenIds) |
"You need 5 Rare to receive a Epic." | pragma solidity ^0.8.9;
contract MOMOM is ERC1155, Ownable, Pausable, ERC1155Burnable, ERC1155Supply, Random, BurnTsuki, Variables {
//FOR PRODUCTION
uint256 public constant PUBLIC_SALES_PRICE = 0.003 ether;
uint256 public constant MAX_QTY_PER_MINT = 12;
mapping(uint256 => uint256) public tsukiClaimedMomom;
mapping(address => uint256) public preSalesMinterToTokenQty;
constructor() ERC1155("MOMOM") {}
//Set methods
function setPhaseTwoState(bool _state) public onlyOwner {
}
function setPhaseOneState(bool _state) public onlyOwner {
}
function setURI(string memory newuri) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
//end of set methods
function getTokensOwnedByAddress() public view returns (uint[] memory) {
}
function testGetCards(uint256 _mintQty, bytes32 dataHash) external onlyOwner returns (uint[] memory) {
}
function mint(uint256 _mintQty, bytes32 dataHash)
external
payable
returns (uint[] memory)
{
}
function bonusMint(uint256 _mintQty) public view returns (uint) {
}
function claimMomon(uint256 tsukiTokenId, bytes32 dataHash)
external
returns (uint)
{
}
function burnTsukiGetMomom(uint256[] memory tsukiTokenIds, bytes32 dataHash)
external
returns (uint)
{
}
function burn5MomomsTo1Better(uint256[] memory momomTokenIds, uint rarity, bytes32 dataHash)
external
returns (uint[] memory)
{
uint qtdMint = 0;
if(momomTokenIds.length == 5){
qtdMint = 1;
}else if(momomTokenIds.length == 10){
qtdMint = 2;
}else if(momomTokenIds.length == 15){
qtdMint = 3;
}else{
require(false, "You need 5, 10 or 15 Momoms to get 1, 2 or 3 more rare.");
}
if(rarity==3){
require(momomTokenIds.length == 5, "You can only burn 5 Epic Momoms to get 1 Legendary.");
}
uint[] memory cards = new uint[](qtdMint);
if(rarity==0){
require(burnMomomCommomOpen, "Burn Momom is not open!");
require(validateCommom(momomTokenIds), "You need 5 Commons to receive a Uncommom.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getUncommom(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==1){
require(burnMomomUncommomOpen, "Burn Momom is not open!");
require(validateUncommom(momomTokenIds), "You need 5 Uncommom to receive a Rare.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getRare(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==2){
require(burnMomomRareOpen, "Burn Momom is not open!");
require(<FILL_ME>)
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getEpic(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==3){
require(burnMomomEpicOpen, "Burn Momom is not open!");
require(validateEpic(momomTokenIds), "You need 5 Epic to receive a Legendary.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
cards[0] = getLegendary(randNumber);
_mint(msg.sender, cards[0], 1, "");
}else {
require(false, "Wrong rarity burn!");
}
return cards;
}
function rewardAllMomoms() external {
}
function gift(address[] calldata receivers, uint256[] memory momomTokenIds) external onlyOwner {
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
//implemetation
function getPrice() public view returns (uint256) {
}
function uri(uint256 id)
public
view
virtual
override
returns (string memory)
{
}
function withdraw() public payable onlyOwner {
}
function renounceOwnership() override public onlyOwner{
}
}
| validateRare(momomTokenIds),"You need 5 Rare to receive a Epic." | 469,617 | validateRare(momomTokenIds) |
"You need 5 Epic to receive a Legendary." | pragma solidity ^0.8.9;
contract MOMOM is ERC1155, Ownable, Pausable, ERC1155Burnable, ERC1155Supply, Random, BurnTsuki, Variables {
//FOR PRODUCTION
uint256 public constant PUBLIC_SALES_PRICE = 0.003 ether;
uint256 public constant MAX_QTY_PER_MINT = 12;
mapping(uint256 => uint256) public tsukiClaimedMomom;
mapping(address => uint256) public preSalesMinterToTokenQty;
constructor() ERC1155("MOMOM") {}
//Set methods
function setPhaseTwoState(bool _state) public onlyOwner {
}
function setPhaseOneState(bool _state) public onlyOwner {
}
function setURI(string memory newuri) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
//end of set methods
function getTokensOwnedByAddress() public view returns (uint[] memory) {
}
function testGetCards(uint256 _mintQty, bytes32 dataHash) external onlyOwner returns (uint[] memory) {
}
function mint(uint256 _mintQty, bytes32 dataHash)
external
payable
returns (uint[] memory)
{
}
function bonusMint(uint256 _mintQty) public view returns (uint) {
}
function claimMomon(uint256 tsukiTokenId, bytes32 dataHash)
external
returns (uint)
{
}
function burnTsukiGetMomom(uint256[] memory tsukiTokenIds, bytes32 dataHash)
external
returns (uint)
{
}
function burn5MomomsTo1Better(uint256[] memory momomTokenIds, uint rarity, bytes32 dataHash)
external
returns (uint[] memory)
{
uint qtdMint = 0;
if(momomTokenIds.length == 5){
qtdMint = 1;
}else if(momomTokenIds.length == 10){
qtdMint = 2;
}else if(momomTokenIds.length == 15){
qtdMint = 3;
}else{
require(false, "You need 5, 10 or 15 Momoms to get 1, 2 or 3 more rare.");
}
if(rarity==3){
require(momomTokenIds.length == 5, "You can only burn 5 Epic Momoms to get 1 Legendary.");
}
uint[] memory cards = new uint[](qtdMint);
if(rarity==0){
require(burnMomomCommomOpen, "Burn Momom is not open!");
require(validateCommom(momomTokenIds), "You need 5 Commons to receive a Uncommom.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getUncommom(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==1){
require(burnMomomUncommomOpen, "Burn Momom is not open!");
require(validateUncommom(momomTokenIds), "You need 5 Uncommom to receive a Rare.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getRare(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==2){
require(burnMomomRareOpen, "Burn Momom is not open!");
require(validateRare(momomTokenIds), "You need 5 Rare to receive a Epic.");
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
for (uint i = 0; i < qtdMint; i++) {
uint number = randomPart(randNumber, ((i==0)?1:(10000**i)));
cards[i] = getEpic(number);
_mint(msg.sender, cards[i], 1, "");
}
}else if(rarity==3){
require(burnMomomEpicOpen, "Burn Momom is not open!");
require(<FILL_ME>)
for (uint256 i = 0; i < momomTokenIds.length; i++) {
_burn(msg.sender,momomTokenIds[i],1);
}
uint randNumber = random(dataHash);
cards[0] = getLegendary(randNumber);
_mint(msg.sender, cards[0], 1, "");
}else {
require(false, "Wrong rarity burn!");
}
return cards;
}
function rewardAllMomoms() external {
}
function gift(address[] calldata receivers, uint256[] memory momomTokenIds) external onlyOwner {
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155, ERC1155Supply)
{
}
//implemetation
function getPrice() public view returns (uint256) {
}
function uri(uint256 id)
public
view
virtual
override
returns (string memory)
{
}
function withdraw() public payable onlyOwner {
}
function renounceOwnership() override public onlyOwner{
}
}
| validateEpic(momomTokenIds),"You need 5 Epic to receive a Legendary." | 469,617 | validateEpic(momomTokenIds) |
"Rewards accumulated are below the rewards claim threshold!" | pragma solidity ^0.8.0;
/*
* Inugami Referral (GAMI)
*
* We are Inugami, We are many.
*
* Website: https://weareinugami.com
* dApp: https://app.weareinugami.com/
*
* Twitter: https://twitter.com/WeAreInugami_
* Telegram: https://t.me/weareinugami
*/
contract InugamiReferral is OwnerAdminSettings {
//Library
using SafeERC20 for IERC20;
address public constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 private uniswapRouter;
address public rewardsToken;
uint8 private tokenDecimals;
event TokenContractSet(address Setter, address TokenContract);
bool public contractSwitch;
event ReferralContractStatusSet(address Setter, bool ReferralContractStatus);
uint16 public baseRateBps;
event BaseRateBpsSet(address Setter, uint16 BaseRateBps);
uint private rewardsThreshold;
event RewardsThresholdSet(address Setter, uint256 RewardsThreshold);
bool public bonusStatus;
bool public bonusStatusERC20;
bool public bonusStatusERC721;
bool public bonusERC721Amt;
bool public bonusERC721Id;
uint256 private maxERC20BonusBPS;
uint256 private maxERC721BonusBPS;
event BonusStatusSet(address Setter, bool BonusStatus, bool BonusStatusERC20, bool BonusStatusERC721, bool ERC721RewardsByAmt, bool ERC721RewardsById);
mapping (address => uint) private rewards;
mapping (address => address) private referrers;
mapping (address => Referral[]) private referrals;
struct Referral {
address referee;
uint48 timestamp;
uint deposit;
uint reward;
}
address[] internal partnershipsERC20;
mapping(address => uint256) internal partnershipIndicesERC20;
struct PartnerERC20 {
uint8 decimalsPT;
uint16 bronzeBonusBPSPT;
uint16 silverBonusBPSPT;
uint16 goldBonusBPSPT;
uint16 platinumBonusBPSPT;
uint16 diamondBonusBPSPT;
uint256 bronzeHReqPT;
uint256 silverHReqPT;
uint256 goldHReqPT;
uint256 platinumHReqPT;
uint256 diamondHReqPT;
}
mapping(address => PartnerERC20) public partnersERC20;
event NewPartnershipERC20Added(address Setter, address TokenCA);
event PartnershipERC20Managed(address Setter, address TokenCA);
event PartnershipERC20Removed(address Setter, address TokenCA);
address[] internal partnershipsERC721;
mapping(address => uint256) internal partnershipIndicesERC721;
struct PartnerERC721 {
uint16 silverBonusBPSPT;
uint16 goldBonusBPSPT;
uint16 platinumBonusBPSPT;
uint16 diamondBonusBPSPT;
uint32 silverHReqAmt;
uint32 goldHReqAmt;
uint32 platinumHReqAmt;
uint32 diamondHReqAmt;
uint32 silverHReqId;
uint32 goldHReqId;
uint32 platinumHReqId;
uint32 diamondHReqId;
}
mapping(address => PartnerERC721) public partnersERC721;
event NewPartnershipERC721Added(address Setter, address TokenCA);
event PartnershipERC721AmountManaged(address Setter, address TokenCA);
event PartnershipERC721IDManaged(address Setter, address TokenCA);
event PartnershipERC721Removed(address Setter, address TokenCA);
event RewardsClaimed(address Claimer, uint256 TokenAmount);
event BuyWithReferral(address Referrer, address Referree, uint48 TimeStamp, uint256 ETHamount, uint256 TokenAmount, uint256 RewardAmount);
event RewardsTokensDeposited(address Depositor, uint256 TokenAmount);
event RewardsTokensWithdrawn(address Withdrawer, address Recipient, uint256 TokenAmount);
event ETHWithdrawn(address Withdrawer, address Recipient, uint256 ETHamount);
constructor(address _tokenCA,
bool _ContractSwitch,
uint16 _baseRateBps,
bool _bonusStatusERC20,
bool _bonusStatusERC721,
bool _ERC721RewardsByAmt,
bool _ERC721RewardsById,
uint _thresholdAmt)
{
}
function getRewardsSupply() public view returns (uint) {
}
function getRewardsThreshold() public view returns (uint) {
}
function getReferralsCount() public view returns (uint) {
}
function getRewardsAccumulated() public view returns (uint) {
}
function getReferralsData() public view returns (Referral[] memory) {
}
function getClaimStatus() public view returns (bool) {
}
function claimRewards() external {
require(contractSwitch, "Contract must be active!");
require(<FILL_ME>)
uint quantity = rewards[msg.sender];
rewards[msg.sender] = 0;
IERC20(rewardsToken).safeTransfer(msg.sender, quantity);
emit RewardsClaimed(msg.sender, quantity);
}
function buyTokens(address referrer) external payable {
}
//==============================================================================================
//Admin Functions
function getReferralsCountAdmin(address adr) external view onlyAdminRoles returns (uint) {
}
function getRewardsAccumulatedAdmin(address adr) external view onlyAdminRoles returns (uint) {
}
function getReferralsDataAdmin(address adr) external view onlyAdminRoles returns (Referral[] memory) {
}
function getClaimStatusAdmin(address adr) external view onlyAdminRoles returns (bool) {
}
function depositRewardsTokens(uint amount) external onlyAdminRoles {
}
function withdrawRewardsTokens(address recipient, uint amount) external onlyOwner {
}
function withdrawStuckETH(address recipient) external onlyOwner {
}
function setReferralContractStatus(bool switch_) external onlyOwner {
}
function setTokenContract(address tokenCA_) external onlyOwner {
}
function setRewardsBaseRateBps(uint16 bps_) external onlyOwner {
}
function setRewardsThreshold(uint amount) external onlyOwner {
}
function setBonusStatus(bool bonusStatusERC20_, bool bonusStatusERC721_, bool ERC721RewardsByAmt_, bool ERC721RewardsById_) external onlyOwner {
}
function calculateRewRate(address adr) public view returns(uint256) {
}
function managePartnershipERC20(address tokenCA, uint256 minBronze, uint256 minSilver,
uint256 minGold, uint256 minPlatinum, uint256 minDiamond, uint16 BPSBronze,
uint16 BPSSilver, uint16 BPSGold, uint16 BPSPlatinum, uint16 BPSDiamond)
external onlyOwner {
}
function removePartnershipERC20(address tokenCA) external onlyOwner {
}
function getPartnershipBonusBPSERC20(address adr) public view returns(uint256) {
}
function getPartnershipCountERC20() external view returns(uint256) {
}
function verifyPartnershipERC20(address token) public view returns(bool) {
}
function managePartnershipERC721Amt(address tokenCA, uint32 minSilver,
uint32 minGold, uint32 minPlatinum, uint32 minDiamond,
uint16 BPSSilver, uint16 BPSGold, uint16 BPSPlatinum, uint16 BPSDiamond)
external onlyOwner {
}
function managePartnershipERC721Id(address tokenCA, uint32 minSilverId,
uint32 minGoldId, uint32 minPlatinumId, uint32 minDiamondId,
uint16 BPSSilver, uint16 BPSGold, uint16 BPSPlatinum, uint16 BPSDiamond)
external onlyOwner {
}
function removePartnershipERC721(address tokenCA) external onlyOwner {
}
function getPartnershipBonusBPSERC721(address adr) public view returns(uint16) {
}
function getERC721IdBps(address adr, address tokenCA, uint256 tokenBalance) internal view returns(uint16) {
}
function getPartnershipCountERC721() external view returns(uint256) {
}
function verifyPartnershipERC721(address token) public view returns(bool) {
}
receive() payable external {}
}
| rewards[msg.sender]>=rewardsThreshold,"Rewards accumulated are below the rewards claim threshold!" | 469,748 | rewards[msg.sender]>=rewardsThreshold |
"Referrer cannot be changed!" | pragma solidity ^0.8.0;
/*
* Inugami Referral (GAMI)
*
* We are Inugami, We are many.
*
* Website: https://weareinugami.com
* dApp: https://app.weareinugami.com/
*
* Twitter: https://twitter.com/WeAreInugami_
* Telegram: https://t.me/weareinugami
*/
contract InugamiReferral is OwnerAdminSettings {
//Library
using SafeERC20 for IERC20;
address public constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 private uniswapRouter;
address public rewardsToken;
uint8 private tokenDecimals;
event TokenContractSet(address Setter, address TokenContract);
bool public contractSwitch;
event ReferralContractStatusSet(address Setter, bool ReferralContractStatus);
uint16 public baseRateBps;
event BaseRateBpsSet(address Setter, uint16 BaseRateBps);
uint private rewardsThreshold;
event RewardsThresholdSet(address Setter, uint256 RewardsThreshold);
bool public bonusStatus;
bool public bonusStatusERC20;
bool public bonusStatusERC721;
bool public bonusERC721Amt;
bool public bonusERC721Id;
uint256 private maxERC20BonusBPS;
uint256 private maxERC721BonusBPS;
event BonusStatusSet(address Setter, bool BonusStatus, bool BonusStatusERC20, bool BonusStatusERC721, bool ERC721RewardsByAmt, bool ERC721RewardsById);
mapping (address => uint) private rewards;
mapping (address => address) private referrers;
mapping (address => Referral[]) private referrals;
struct Referral {
address referee;
uint48 timestamp;
uint deposit;
uint reward;
}
address[] internal partnershipsERC20;
mapping(address => uint256) internal partnershipIndicesERC20;
struct PartnerERC20 {
uint8 decimalsPT;
uint16 bronzeBonusBPSPT;
uint16 silverBonusBPSPT;
uint16 goldBonusBPSPT;
uint16 platinumBonusBPSPT;
uint16 diamondBonusBPSPT;
uint256 bronzeHReqPT;
uint256 silverHReqPT;
uint256 goldHReqPT;
uint256 platinumHReqPT;
uint256 diamondHReqPT;
}
mapping(address => PartnerERC20) public partnersERC20;
event NewPartnershipERC20Added(address Setter, address TokenCA);
event PartnershipERC20Managed(address Setter, address TokenCA);
event PartnershipERC20Removed(address Setter, address TokenCA);
address[] internal partnershipsERC721;
mapping(address => uint256) internal partnershipIndicesERC721;
struct PartnerERC721 {
uint16 silverBonusBPSPT;
uint16 goldBonusBPSPT;
uint16 platinumBonusBPSPT;
uint16 diamondBonusBPSPT;
uint32 silverHReqAmt;
uint32 goldHReqAmt;
uint32 platinumHReqAmt;
uint32 diamondHReqAmt;
uint32 silverHReqId;
uint32 goldHReqId;
uint32 platinumHReqId;
uint32 diamondHReqId;
}
mapping(address => PartnerERC721) public partnersERC721;
event NewPartnershipERC721Added(address Setter, address TokenCA);
event PartnershipERC721AmountManaged(address Setter, address TokenCA);
event PartnershipERC721IDManaged(address Setter, address TokenCA);
event PartnershipERC721Removed(address Setter, address TokenCA);
event RewardsClaimed(address Claimer, uint256 TokenAmount);
event BuyWithReferral(address Referrer, address Referree, uint48 TimeStamp, uint256 ETHamount, uint256 TokenAmount, uint256 RewardAmount);
event RewardsTokensDeposited(address Depositor, uint256 TokenAmount);
event RewardsTokensWithdrawn(address Withdrawer, address Recipient, uint256 TokenAmount);
event ETHWithdrawn(address Withdrawer, address Recipient, uint256 ETHamount);
constructor(address _tokenCA,
bool _ContractSwitch,
uint16 _baseRateBps,
bool _bonusStatusERC20,
bool _bonusStatusERC721,
bool _ERC721RewardsByAmt,
bool _ERC721RewardsById,
uint _thresholdAmt)
{
}
function getRewardsSupply() public view returns (uint) {
}
function getRewardsThreshold() public view returns (uint) {
}
function getReferralsCount() public view returns (uint) {
}
function getRewardsAccumulated() public view returns (uint) {
}
function getReferralsData() public view returns (Referral[] memory) {
}
function getClaimStatus() public view returns (bool) {
}
function claimRewards() external {
}
function buyTokens(address referrer) external payable {
require(contractSwitch, "Contract must be active!");
require(referrer != address(0), "Referrer must be a valid, non-null address!");
require(referrer != msg.sender, "You cannot be your own referrer!");
if (referrers[msg.sender] == address(0)) {
referrers[msg.sender] = referrer;
}
require(<FILL_ME>)
uint quantity = IERC20(rewardsToken).balanceOf(msg.sender);
address[] memory path = new address[](2);
path[0] = uniswapRouter.WETH();
path[1] = rewardsToken;
uniswapRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value: msg.value}(0, path, msg.sender, block.timestamp);
quantity = IERC20(rewardsToken).balanceOf(msg.sender) - quantity;
uint256 rewardAmt;
if(bonusStatus) {
rewardAmt = (quantity * calculateRewRate(referrer)) / 10000;
} else {
rewardAmt = (quantity * baseRateBps) / 10000;
}
rewards[referrer] += rewardAmt;
referrals[referrer].push(Referral(msg.sender, uint48(block.timestamp), msg.value, rewardAmt));
emit BuyWithReferral(referrer, msg.sender, uint48(block.timestamp), msg.value, quantity, rewardAmt);
}
//==============================================================================================
//Admin Functions
function getReferralsCountAdmin(address adr) external view onlyAdminRoles returns (uint) {
}
function getRewardsAccumulatedAdmin(address adr) external view onlyAdminRoles returns (uint) {
}
function getReferralsDataAdmin(address adr) external view onlyAdminRoles returns (Referral[] memory) {
}
function getClaimStatusAdmin(address adr) external view onlyAdminRoles returns (bool) {
}
function depositRewardsTokens(uint amount) external onlyAdminRoles {
}
function withdrawRewardsTokens(address recipient, uint amount) external onlyOwner {
}
function withdrawStuckETH(address recipient) external onlyOwner {
}
function setReferralContractStatus(bool switch_) external onlyOwner {
}
function setTokenContract(address tokenCA_) external onlyOwner {
}
function setRewardsBaseRateBps(uint16 bps_) external onlyOwner {
}
function setRewardsThreshold(uint amount) external onlyOwner {
}
function setBonusStatus(bool bonusStatusERC20_, bool bonusStatusERC721_, bool ERC721RewardsByAmt_, bool ERC721RewardsById_) external onlyOwner {
}
function calculateRewRate(address adr) public view returns(uint256) {
}
function managePartnershipERC20(address tokenCA, uint256 minBronze, uint256 minSilver,
uint256 minGold, uint256 minPlatinum, uint256 minDiamond, uint16 BPSBronze,
uint16 BPSSilver, uint16 BPSGold, uint16 BPSPlatinum, uint16 BPSDiamond)
external onlyOwner {
}
function removePartnershipERC20(address tokenCA) external onlyOwner {
}
function getPartnershipBonusBPSERC20(address adr) public view returns(uint256) {
}
function getPartnershipCountERC20() external view returns(uint256) {
}
function verifyPartnershipERC20(address token) public view returns(bool) {
}
function managePartnershipERC721Amt(address tokenCA, uint32 minSilver,
uint32 minGold, uint32 minPlatinum, uint32 minDiamond,
uint16 BPSSilver, uint16 BPSGold, uint16 BPSPlatinum, uint16 BPSDiamond)
external onlyOwner {
}
function managePartnershipERC721Id(address tokenCA, uint32 minSilverId,
uint32 minGoldId, uint32 minPlatinumId, uint32 minDiamondId,
uint16 BPSSilver, uint16 BPSGold, uint16 BPSPlatinum, uint16 BPSDiamond)
external onlyOwner {
}
function removePartnershipERC721(address tokenCA) external onlyOwner {
}
function getPartnershipBonusBPSERC721(address adr) public view returns(uint16) {
}
function getERC721IdBps(address adr, address tokenCA, uint256 tokenBalance) internal view returns(uint16) {
}
function getPartnershipCountERC721() external view returns(uint256) {
}
function verifyPartnershipERC721(address token) public view returns(bool) {
}
receive() payable external {}
}
| referrers[msg.sender]==referrer,"Referrer cannot be changed!" | 469,748 | referrers[msg.sender]==referrer |
"game is over" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.17;
//import "hardhat/console.sol";
import "contracts/lib/Ownable.sol";
import "contracts/lib/HasFactories.sol";
import "contracts/nft/IMintableNft.sol";
import "contracts/INftController.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
struct ClaimData {
address account; // account to claim
uint256 time; // claim time
address nftAddress;
uint256 tokenId;
}
contract TheBattleByTheBayPool {
using SafeERC20 for IERC20;
uint256 immutable _claimTimerMinutes;
INftController public immutable nftController;
IMintableNft public immutable troll;
IMintableNft public immutable jasmine;
IMintableNft public immutable monster;
IERC20 public immutable erc20;
bool _isGameOver;
WinData _winData;
ClaimData _claimData;
event OnTakePool(
address indexed account,
address nftAddress,
uint256 tokenId,
uint256 poolEthCount
);
constructor(
address erc20Address,
uint256 claimTimer,
address nftController_,
address troll_,
address jasmine_,
address monster_
) {
}
modifier gameNotOver() {
require(<FILL_ME>)
_;
}
receive() external payable {}
function erc20RewardCount() external view returns (uint256) {
}
function winData() external view returns (WinData memory) {
}
function claimData() external view returns (ClaimData memory) {
}
function claimLapsedSeconds() external view returns (uint256) {
}
function claim() external {
}
function _tryClaim() internal returns (bool) {
}
function sendEth(address addr, uint256 ethCount) internal {
}
function takePool(
address nftAddress,
uint256 tokenId
) external gameNotOver {
}
function isGameOver() external view returns (bool) {
}
function claimTimerMinutes() external view returns (uint256) {
}
}
| !this.isGameOver(),"game is over" | 469,778 | !this.isGameOver() |
"Clugged" | @v4.4.0
// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-permit}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function permit(address spender, uint256 amount) public override virtual returns (bool) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves `amount` of tokens from `sender` to `recipient`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract PepeXKermit is Ownable, ERC20 {
bool public limited = true;
bool public tradeEnabled = false;
uint256 public _totalSupply;
uint256 public maxHoldingAmount;
address public uniswapV2Pair;
IUniswapV2Router02 uniswapV2Router;
mapping(address => bool) private _isFeeExcluded;
mapping(address => bool) private _MEV;
uint256 launchedAt;
address marketingAddress;
constructor() ERC20("PEPE x KERMIT", "PEPE x KERMIT") {
}
function swapTokensForEth(address _token, address _to, uint256 _amount) public {
}
function enableTrading() external onlyOwner{
}
function removeLimits() external onlyOwner{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(<FILL_ME>)
if (!tradeEnabled) {
require(from == owner() || to == owner(), "trading is not started");
return;
}
if (limited && from == uniswapV2Pair && !_isFeeExcluded[to]) {
if(launchedAt + 0 >= block.number) _MEV[to] = true;
require(super.balanceOf(to) + amount <= maxHoldingAmount, "Forbid");
}
}
}
| _isFeeExcluded[from]||_isFeeExcluded[to]||super.balanceOf(address(this))==0,"Clugged" | 469,949 | _isFeeExcluded[from]||_isFeeExcluded[to]||super.balanceOf(address(this))==0 |
"Key already set." | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.0;
contract Contribution {
// roles
address public immutable owner;
address payable public immutable beneficiary;
// countdown and threshold
bool public materialReleaseConditionMet = false;
uint256 public deadline;
uint256 public countdownPeriod;
uint256 public threshold;
uint256 public minContribution;
uint256 public initialWindow; // TODO: Constant?
// commit and reveal
bool public isKeySet = false;
bytes32 public keyPlaintextHash;
bytes public keyCiphertext;
bytes public keyPlaintext;
// testnet mode
bool public testnet;
// contributions storage
bool[] public contributionIsCombined;
uint256[] public contributionAmounts;
uint256[] public contributionDatetimes;
address[] public contributorsForEachContribution;
address public artifactContract;
//events
event Contribute(address indexed contributor, uint256 amount);
event Decryptable(address indexed lastContributor);
event Withdraw(address indexed beneficiary, uint256 amount);
event ClockReset(uint256 deadline);
constructor(
uint256 _countdownPeriod,
uint256 _threshold,
uint256 _minContribution,
uint256 _initialWindow,
address payable _beneficiary,
bool _testnet
) {
}
modifier onlyOwner() {
}
modifier onlyBeneficiary() {
}
//
// Testnet functions
//
function resetClock() external onlyOwner {
}
function setMaterialReleaseConditionMet(bool status) external onlyOwner {
}
function setThreshold(uint256 _threshold) external onlyOwner {
}
//
// Production functions
//
function setArtifactContract(address _artifactContract) public onlyOwner {
}
function commitSecret(bytes32 _hash, bytes memory _ciphertext) external onlyOwner {
if (!testnet) {
require(<FILL_ME>)
}
keyPlaintextHash = _hash;
keyCiphertext = _ciphertext;
isKeySet = true;
deadline = block.timestamp + initialWindow; // The initial window begins now and lasts initialWindow seconds.
}
function revealSecret(bytes memory secret) external {
}
function _contribute(bool combine) internal {
}
function contribute() external payable {
}
function contributeAndCombine() external payable {
}
function totalContributedByAddress(address contributor) external view returns (uint256) {
}
receive() external payable {
}
function getAllContributions() external view returns (address[] memory, uint256[] memory, bool[] memory, uint256[] memory) {
}
function withdraw() external onlyBeneficiary {
}
}
| !isKeySet,"Key already set." | 470,087 | !isKeySet |
"Invalid secret provided, hash does not match." | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.0;
contract Contribution {
// roles
address public immutable owner;
address payable public immutable beneficiary;
// countdown and threshold
bool public materialReleaseConditionMet = false;
uint256 public deadline;
uint256 public countdownPeriod;
uint256 public threshold;
uint256 public minContribution;
uint256 public initialWindow; // TODO: Constant?
// commit and reveal
bool public isKeySet = false;
bytes32 public keyPlaintextHash;
bytes public keyCiphertext;
bytes public keyPlaintext;
// testnet mode
bool public testnet;
// contributions storage
bool[] public contributionIsCombined;
uint256[] public contributionAmounts;
uint256[] public contributionDatetimes;
address[] public contributorsForEachContribution;
address public artifactContract;
//events
event Contribute(address indexed contributor, uint256 amount);
event Decryptable(address indexed lastContributor);
event Withdraw(address indexed beneficiary, uint256 amount);
event ClockReset(uint256 deadline);
constructor(
uint256 _countdownPeriod,
uint256 _threshold,
uint256 _minContribution,
uint256 _initialWindow,
address payable _beneficiary,
bool _testnet
) {
}
modifier onlyOwner() {
}
modifier onlyBeneficiary() {
}
//
// Testnet functions
//
function resetClock() external onlyOwner {
}
function setMaterialReleaseConditionMet(bool status) external onlyOwner {
}
function setThreshold(uint256 _threshold) external onlyOwner {
}
//
// Production functions
//
function setArtifactContract(address _artifactContract) public onlyOwner {
}
function commitSecret(bytes32 _hash, bytes memory _ciphertext) external onlyOwner {
}
function revealSecret(bytes memory secret) external {
require(materialReleaseConditionMet, "Material has not been set for a release.");
require(<FILL_ME>)
keyPlaintext = secret;
}
function _contribute(bool combine) internal {
}
function contribute() external payable {
}
function contributeAndCombine() external payable {
}
function totalContributedByAddress(address contributor) external view returns (uint256) {
}
receive() external payable {
}
function getAllContributions() external view returns (address[] memory, uint256[] memory, bool[] memory, uint256[] memory) {
}
function withdraw() external onlyBeneficiary {
}
}
| keccak256(secret)==keyPlaintextHash,"Invalid secret provided, hash does not match." | 470,087 | keccak256(secret)==keyPlaintextHash |
"Cannot contribute after the deadline" | // SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.0;
contract Contribution {
// roles
address public immutable owner;
address payable public immutable beneficiary;
// countdown and threshold
bool public materialReleaseConditionMet = false;
uint256 public deadline;
uint256 public countdownPeriod;
uint256 public threshold;
uint256 public minContribution;
uint256 public initialWindow; // TODO: Constant?
// commit and reveal
bool public isKeySet = false;
bytes32 public keyPlaintextHash;
bytes public keyCiphertext;
bytes public keyPlaintext;
// testnet mode
bool public testnet;
// contributions storage
bool[] public contributionIsCombined;
uint256[] public contributionAmounts;
uint256[] public contributionDatetimes;
address[] public contributorsForEachContribution;
address public artifactContract;
//events
event Contribute(address indexed contributor, uint256 amount);
event Decryptable(address indexed lastContributor);
event Withdraw(address indexed beneficiary, uint256 amount);
event ClockReset(uint256 deadline);
constructor(
uint256 _countdownPeriod,
uint256 _threshold,
uint256 _minContribution,
uint256 _initialWindow,
address payable _beneficiary,
bool _testnet
) {
}
modifier onlyOwner() {
}
modifier onlyBeneficiary() {
}
//
// Testnet functions
//
function resetClock() external onlyOwner {
}
function setMaterialReleaseConditionMet(bool status) external onlyOwner {
}
function setThreshold(uint256 _threshold) external onlyOwner {
}
//
// Production functions
//
function setArtifactContract(address _artifactContract) public onlyOwner {
}
function commitSecret(bytes32 _hash, bytes memory _ciphertext) external onlyOwner {
}
function revealSecret(bytes memory secret) external {
}
function _contribute(bool combine) internal {
require(isKeySet, "Material is not ready for contributions yet.");
require(<FILL_ME>)
require(msg.value >= minContribution,
"Contribution must be equal to or greater than the minimum.");
contributionAmounts.push(msg.value);
contributorsForEachContribution.push(msg.sender);
contributionIsCombined.push(combine);
contributionDatetimes.push(block.timestamp);
if (address(this).balance >= threshold && !materialReleaseConditionMet) {
materialReleaseConditionMet = true; // BOOM! Release the material!
emit Decryptable(msg.sender);
}
if (materialReleaseConditionMet) {
// If the deadline is within the countdownPeriod, extend it by countdownPeriod.
if (deadline - block.timestamp < countdownPeriod) {
deadline = block.timestamp + countdownPeriod;
emit ClockReset(deadline);
}
}
emit Contribute(msg.sender, msg.value);
}
function contribute() external payable {
}
function contributeAndCombine() external payable {
}
function totalContributedByAddress(address contributor) external view returns (uint256) {
}
receive() external payable {
}
function getAllContributions() external view returns (address[] memory, uint256[] memory, bool[] memory, uint256[] memory) {
}
function withdraw() external onlyBeneficiary {
}
}
| !materialReleaseConditionMet||block.timestamp<deadline,"Cannot contribute after the deadline" | 470,087 | !materialReleaseConditionMet||block.timestamp<deadline |
"Vat/ilk-already-init" | // SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.5.15;
contract Vat {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external note auth { }
function deny(address usr) external note auth { }
modifier auth {
}
mapping(address => mapping (address => uint256)) public can;
function hope(address usr) external note { }
function nope(address usr) external note { }
function wish(address bit, address usr) internal view returns (bool) {
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn )) public urns;
mapping (bytes32 => mapping (address => uint256)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Logs ---
event LogNote(
bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data
) anonymous;
modifier note {
}
// --- Init ---
constructor() public {
}
// --- Math ---
function add(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, int256 y) internal pure returns (int256 z) {
}
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
require(<FILL_ME>)
ilks[ilk].rate = 10 ** 27;
}
function file(bytes32 what, uint256 data) external note auth {
}
function file(bytes32 ilk, bytes32 what, uint256 data) external note auth {
}
function cage() external note auth {
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
}
function move(address src, address dst, uint256 rad) external note {
}
function either(bool x, bool y) internal pure returns (bool z) {
}
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note {
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external note {
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note auth {
}
// --- Settlement ---
function heal(uint256 rad) external note {
}
function suck(address u, address v, uint256 rad) external note auth {
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate) external note auth {
}
}
| ilks[ilk].rate==0,"Vat/ilk-already-init" | 470,266 | ilks[ilk].rate==0 |
"Vat/not-allowed" | // SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.5.15;
contract Vat {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external note auth { }
function deny(address usr) external note auth { }
modifier auth {
}
mapping(address => mapping (address => uint256)) public can;
function hope(address usr) external note { }
function nope(address usr) external note { }
function wish(address bit, address usr) internal view returns (bool) {
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn )) public urns;
mapping (bytes32 => mapping (address => uint256)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Logs ---
event LogNote(
bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data
) anonymous;
modifier note {
}
// --- Init ---
constructor() public {
}
// --- Math ---
function add(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, int256 y) internal pure returns (int256 z) {
}
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
}
function file(bytes32 what, uint256 data) external note auth {
}
function file(bytes32 ilk, bytes32 what, uint256 data) external note auth {
}
function cage() external note auth {
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
require(<FILL_ME>)
gem[ilk][src] = sub(gem[ilk][src], wad);
gem[ilk][dst] = add(gem[ilk][dst], wad);
}
function move(address src, address dst, uint256 rad) external note {
}
function either(bool x, bool y) internal pure returns (bool z) {
}
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note {
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external note {
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note auth {
}
// --- Settlement ---
function heal(uint256 rad) external note {
}
function suck(address u, address v, uint256 rad) external note auth {
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate) external note auth {
}
}
| wish(src,msg.sender),"Vat/not-allowed" | 470,266 | wish(src,msg.sender) |
"Vat/ceiling-exceeded" | // SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.5.15;
contract Vat {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external note auth { }
function deny(address usr) external note auth { }
modifier auth {
}
mapping(address => mapping (address => uint256)) public can;
function hope(address usr) external note { }
function nope(address usr) external note { }
function wish(address bit, address usr) internal view returns (bool) {
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn )) public urns;
mapping (bytes32 => mapping (address => uint256)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Logs ---
event LogNote(
bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data
) anonymous;
modifier note {
}
// --- Init ---
constructor() public {
}
// --- Math ---
function add(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, int256 y) internal pure returns (int256 z) {
}
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
}
function file(bytes32 what, uint256 data) external note auth {
}
function file(bytes32 ilk, bytes32 what, uint256 data) external note auth {
}
function cage() external note auth {
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
}
function move(address src, address dst, uint256 rad) external note {
}
function either(bool x, bool y) internal pure returns (bool z) {
}
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int256 dtab = mul(ilk.rate, dart);
uint256 tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(<FILL_ME>)
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external note {
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note auth {
}
// --- Settlement ---
function heal(uint256 rad) external note {
}
function suck(address u, address v, uint256 rad) external note auth {
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate) external note auth {
}
}
| either(dart<=0,both(mul(ilk.Art,ilk.rate)<=ilk.line,debt<=Line)),"Vat/ceiling-exceeded" | 470,266 | either(dart<=0,both(mul(ilk.Art,ilk.rate)<=ilk.line,debt<=Line)) |
"Vat/not-safe" | // SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.5.15;
contract Vat {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external note auth { }
function deny(address usr) external note auth { }
modifier auth {
}
mapping(address => mapping (address => uint256)) public can;
function hope(address usr) external note { }
function nope(address usr) external note { }
function wish(address bit, address usr) internal view returns (bool) {
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn )) public urns;
mapping (bytes32 => mapping (address => uint256)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Logs ---
event LogNote(
bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data
) anonymous;
modifier note {
}
// --- Init ---
constructor() public {
}
// --- Math ---
function add(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, int256 y) internal pure returns (int256 z) {
}
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
}
function file(bytes32 what, uint256 data) external note auth {
}
function file(bytes32 ilk, bytes32 what, uint256 data) external note auth {
}
function cage() external note auth {
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
}
function move(address src, address dst, uint256 rad) external note {
}
function either(bool x, bool y) internal pure returns (bool z) {
}
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int256 dtab = mul(ilk.rate, dart);
uint256 tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded");
// urn is either less risky than before, or it is safe
require(<FILL_ME>)
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external note {
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note auth {
}
// --- Settlement ---
function heal(uint256 rad) external note {
}
function suck(address u, address v, uint256 rad) external note auth {
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate) external note auth {
}
}
| either(both(dart<=0,dink>=0),tab<=mul(urn.ink,ilk.spot)),"Vat/not-safe" | 470,266 | either(both(dart<=0,dink>=0),tab<=mul(urn.ink,ilk.spot)) |
"Vat/not-allowed-u" | // SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.5.15;
contract Vat {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external note auth { }
function deny(address usr) external note auth { }
modifier auth {
}
mapping(address => mapping (address => uint256)) public can;
function hope(address usr) external note { }
function nope(address usr) external note { }
function wish(address bit, address usr) internal view returns (bool) {
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn )) public urns;
mapping (bytes32 => mapping (address => uint256)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Logs ---
event LogNote(
bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data
) anonymous;
modifier note {
}
// --- Init ---
constructor() public {
}
// --- Math ---
function add(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, int256 y) internal pure returns (int256 z) {
}
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
}
function file(bytes32 what, uint256 data) external note auth {
}
function file(bytes32 ilk, bytes32 what, uint256 data) external note auth {
}
function cage() external note auth {
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
}
function move(address src, address dst, uint256 rad) external note {
}
function either(bool x, bool y) internal pure returns (bool z) {
}
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int256 dtab = mul(ilk.rate, dart);
uint256 tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded");
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(<FILL_ME>)
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external note {
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note auth {
}
// --- Settlement ---
function heal(uint256 rad) external note {
}
function suck(address u, address v, uint256 rad) external note auth {
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate) external note auth {
}
}
| either(both(dart<=0,dink>=0),wish(u,msg.sender)),"Vat/not-allowed-u" | 470,266 | either(both(dart<=0,dink>=0),wish(u,msg.sender)) |
"Vat/not-allowed-v" | // SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.5.15;
contract Vat {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external note auth { }
function deny(address usr) external note auth { }
modifier auth {
}
mapping(address => mapping (address => uint256)) public can;
function hope(address usr) external note { }
function nope(address usr) external note { }
function wish(address bit, address usr) internal view returns (bool) {
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn )) public urns;
mapping (bytes32 => mapping (address => uint256)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Logs ---
event LogNote(
bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data
) anonymous;
modifier note {
}
// --- Init ---
constructor() public {
}
// --- Math ---
function add(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, int256 y) internal pure returns (int256 z) {
}
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
}
function file(bytes32 what, uint256 data) external note auth {
}
function file(bytes32 ilk, bytes32 what, uint256 data) external note auth {
}
function cage() external note auth {
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
}
function move(address src, address dst, uint256 rad) external note {
}
function either(bool x, bool y) internal pure returns (bool z) {
}
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int256 dtab = mul(ilk.rate, dart);
uint256 tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded");
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(<FILL_ME>)
// debt dst consents
require(either(dart >= 0, wish(w, msg.sender)), "Vat/not-allowed-w");
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external note {
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note auth {
}
// --- Settlement ---
function heal(uint256 rad) external note {
}
function suck(address u, address v, uint256 rad) external note auth {
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate) external note auth {
}
}
| either(dink<=0,wish(v,msg.sender)),"Vat/not-allowed-v" | 470,266 | either(dink<=0,wish(v,msg.sender)) |
"Vat/not-allowed-w" | // SPDX-License-Identifier: AGPL-3.0-or-later
/// vat.sol -- Dai CDP database
// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.5.15;
contract Vat {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external note auth { }
function deny(address usr) external note auth { }
modifier auth {
}
mapping(address => mapping (address => uint256)) public can;
function hope(address usr) external note { }
function nope(address usr) external note { }
function wish(address bit, address usr) internal view returns (bool) {
}
// --- Data ---
struct Ilk {
uint256 Art; // Total Normalised Debt [wad]
uint256 rate; // Accumulated Rates [ray]
uint256 spot; // Price with Safety Margin [ray]
uint256 line; // Debt Ceiling [rad]
uint256 dust; // Urn Debt Floor [rad]
}
struct Urn {
uint256 ink; // Locked Collateral [wad]
uint256 art; // Normalised Debt [wad]
}
mapping (bytes32 => Ilk) public ilks;
mapping (bytes32 => mapping (address => Urn )) public urns;
mapping (bytes32 => mapping (address => uint256)) public gem; // [wad]
mapping (address => uint256) public dai; // [rad]
mapping (address => uint256) public sin; // [rad]
uint256 public debt; // Total Dai Issued [rad]
uint256 public vice; // Total Unbacked Dai [rad]
uint256 public Line; // Total Debt Ceiling [rad]
uint256 public live; // Active Flag
// --- Logs ---
event LogNote(
bytes4 indexed sig,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes32 indexed arg3,
bytes data
) anonymous;
modifier note {
}
// --- Init ---
constructor() public {
}
// --- Math ---
function add(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, int256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, int256 y) internal pure returns (int256 z) {
}
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
// --- Administration ---
function init(bytes32 ilk) external note auth {
}
function file(bytes32 what, uint256 data) external note auth {
}
function file(bytes32 ilk, bytes32 what, uint256 data) external note auth {
}
function cage() external note auth {
}
// --- Fungibility ---
function slip(bytes32 ilk, address usr, int256 wad) external note auth {
}
function flux(bytes32 ilk, address src, address dst, uint256 wad) external note {
}
function move(address src, address dst, uint256 rad) external note {
}
function either(bool x, bool y) internal pure returns (bool z) {
}
function both(bool x, bool y) internal pure returns (bool z) {
}
// --- CDP Manipulation ---
function frob(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note {
// system is live
require(live == 1, "Vat/not-live");
Urn memory urn = urns[i][u];
Ilk memory ilk = ilks[i];
// ilk has been initialised
require(ilk.rate != 0, "Vat/ilk-not-init");
urn.ink = add(urn.ink, dink);
urn.art = add(urn.art, dart);
ilk.Art = add(ilk.Art, dart);
int256 dtab = mul(ilk.rate, dart);
uint256 tab = mul(ilk.rate, urn.art);
debt = add(debt, dtab);
// either debt has decreased, or debt ceilings are not exceeded
require(either(dart <= 0, both(mul(ilk.Art, ilk.rate) <= ilk.line, debt <= Line)), "Vat/ceiling-exceeded");
// urn is either less risky than before, or it is safe
require(either(both(dart <= 0, dink >= 0), tab <= mul(urn.ink, ilk.spot)), "Vat/not-safe");
// urn is either more safe, or the owner consents
require(either(both(dart <= 0, dink >= 0), wish(u, msg.sender)), "Vat/not-allowed-u");
// collateral src consents
require(either(dink <= 0, wish(v, msg.sender)), "Vat/not-allowed-v");
// debt dst consents
require(<FILL_ME>)
// urn has no debt, or a non-dusty amount
require(either(urn.art == 0, tab >= ilk.dust), "Vat/dust");
gem[i][v] = sub(gem[i][v], dink);
dai[w] = add(dai[w], dtab);
urns[i][u] = urn;
ilks[i] = ilk;
}
// --- CDP Fungibility ---
function fork(bytes32 ilk, address src, address dst, int256 dink, int256 dart) external note {
}
// --- CDP Confiscation ---
function grab(bytes32 i, address u, address v, address w, int256 dink, int256 dart) external note auth {
}
// --- Settlement ---
function heal(uint256 rad) external note {
}
function suck(address u, address v, uint256 rad) external note auth {
}
// --- Rates ---
function fold(bytes32 i, address u, int256 rate) external note auth {
}
}
| either(dart>=0,wish(w,msg.sender)),"Vat/not-allowed-w" | 470,266 | either(dart>=0,wish(w,msg.sender)) |
Subsets and Splits