comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Consensus has not been reached" | /**
* .
* / \
* |.'.|
* |'.'|
* ,'| |`.
* |,-'-|-'-.|
* __|_| | _ _ _____ _
* | ___ \| | | | | | ___ \ | |
* | |_/ /|__ ___| | _____| |_ | |_/ /__ ___ | |
* | // _ \ / __| |/ / _ \ __| | __/ _ \ / _ \| |
* | |\ \ (_) | (__| < __/ |_ | | | (_) | (_) | |
* \_| \_\___/ \___|_|\_\___|\__| \_| \___/ \___/|_|
* +---------------------------------------------------+
* | DECENTRALISED STAKING PROTOCOL FOR ETHEREUM |
* +---------------------------------------------------+
*
* Rocket Pool is a first-of-its-kind Ethereum staking pool protocol, designed to
* be community-owned, decentralised, and trustless.
*
* For more information about Rocket Pool, visit https://rocketpool.net
*
* Authors: David Rugendyke, Jake Pospischil, Kane Wallmann, Darren Langley, Joe Clapis, Nick Doherty
*
*/
pragma solidity 0.7.6;
// SPDX-License-Identifier: GPL-3.0-only
import "@openzeppelin/contracts/math/SafeMath.sol";
import "../RocketBase.sol";
import "../../interface/dao/node/RocketDAONodeTrustedInterface.sol";
import "../../interface/network/RocketNetworkPricesInterface.sol";
import "../../interface/dao/protocol/settings/RocketDAOProtocolSettingsNetworkInterface.sol";
// Network token price data
contract RocketNetworkPrices is RocketBase, RocketNetworkPricesInterface {
// Libs
using SafeMath for uint;
// Events
event PricesSubmitted(address indexed from, uint256 block, uint256 rplPrice, uint256 effectiveRplStake, uint256 time);
event PricesUpdated(uint256 block, uint256 rplPrice, uint256 effectiveRplStake, uint256 time);
// Construct
constructor(RocketStorageInterface _rocketStorageAddress) RocketBase(_rocketStorageAddress) {
}
// The block number which prices are current for
function getPricesBlock() override public view returns (uint256) {
}
function setPricesBlock(uint256 _value) private {
}
// The current RP network RPL price in ETH
function getRPLPrice() override external view returns (uint256) {
}
function setRPLPrice(uint256 _value) private {
}
// The current RP network effective RPL stake
function getEffectiveRPLStake() override external view returns (uint256) {
}
function getEffectiveRPLStakeUpdatedBlock() override public view returns (uint256) {
}
function setEffectiveRPLStake(uint256 _value) private {
}
function increaseEffectiveRPLStake(uint256 _amount) override external onlyLatestNetworkContract {
}
function decreaseEffectiveRPLStake(uint256 _amount) override external onlyLatestNetworkContract {
}
// Submit network price data for a block
// Only accepts calls from trusted (oracle) nodes
function submitPrices(uint256 _block, uint256 _rplPrice, uint256 _effectiveRplStake) override external onlyLatestContract("rocketNetworkPrices", address(this)) onlyTrustedNode(msg.sender) {
}
// Executes updatePrices if consensus threshold is reached
function executeUpdatePrices(uint256 _block, uint256 _rplPrice, uint256 _effectiveRplStake) override external onlyLatestContract("rocketNetworkPrices", address(this)) {
// Check settings
RocketDAOProtocolSettingsNetworkInterface rocketDAOProtocolSettingsNetwork = RocketDAOProtocolSettingsNetworkInterface(getContractAddress("rocketDAOProtocolSettingsNetwork"));
require(rocketDAOProtocolSettingsNetwork.getSubmitPricesEnabled(), "Submitting prices is currently disabled");
// Check block
require(_block < block.number, "Prices can not be submitted for a future block");
require(_block > getPricesBlock(), "Network prices for an equal or higher block are set");
// Get submission keys
bytes32 submissionCountKey = keccak256(abi.encodePacked("network.prices.submitted.count", _block, _rplPrice, _effectiveRplStake));
// Get submission count
uint256 submissionCount = getUint(submissionCountKey);
// Check submission count & update network prices
RocketDAONodeTrustedInterface rocketDAONodeTrusted = RocketDAONodeTrustedInterface(getContractAddress("rocketDAONodeTrusted"));
require(<FILL_ME>)
// Update the price
updatePrices(_block, _rplPrice, _effectiveRplStake);
}
// Update network price data
function updatePrices(uint256 _block, uint256 _rplPrice, uint256 _effectiveRplStake) private {
}
// Returns true if consensus has been reached for the last price reportable block
function inConsensus() override public view returns (bool) {
}
// Returns the latest block number that oracles should be reporting prices for
function getLatestReportableBlock() override external view returns (uint256) {
}
}
| calcBase.mul(submissionCount).div(rocketDAONodeTrusted.getMemberCount())>=rocketDAOProtocolSettingsNetwork.getNodeConsensusThreshold(),"Consensus has not been reached" | 319,175 | calcBase.mul(submissionCount).div(rocketDAONodeTrusted.getMemberCount())>=rocketDAOProtocolSettingsNetwork.getNodeConsensusThreshold() |
null | /**
* @title TokenTimelock Controller
* @dev This contract allows to create/read/revoke TokenTimelock contracts and to claim the amounts vested.
**/
contract TokenTimelockController is Ownable {
using SafeMath for uint;
struct TokenTimelock {
uint256 amount;
uint256 releaseTime;
bool released;
bool revocable;
bool revoked;
}
event TokenTimelockCreated(
address indexed beneficiary,
uint256 releaseTime,
bool revocable,
uint256 amount
);
event TokenTimelockRevoked(
address indexed beneficiary
);
event TokenTimelockBeneficiaryChanged(
address indexed previousBeneficiary,
address indexed newBeneficiary
);
event TokenTimelockReleased(
address indexed beneficiary,
uint256 amount
);
uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days;
uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days;
uint256 public constant INVESTOR_LOCK_DURATION = 6 * 30 days;
mapping (address => TokenTimelock[]) tokenTimeLocks;
ERC20 public token;
address public crowdsale;
bool public activated;
/// @notice Constructor for TokenTimelock Controller
constructor(ERC20 _token) public {
}
modifier onlyCrowdsale() {
}
modifier onlyWhenActivated() {
}
modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) {
require(_beneficiary != address(0));
require(_id < tokenTimeLocks[_beneficiary].length);
require(<FILL_ME>)
_;
}
/**
* @dev Function to set the crowdsale address
* @param _crowdsale address The address of the crowdsale.
*/
function setCrowdsale(address _crowdsale) external onlyOwner {
}
/**
* @dev Function to activate the controller.
* It can be called only by the crowdsale address.
*/
function activate() external onlyCrowdsale {
}
/**
* @dev Creates a lock for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the address of the crowdsale;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The investors will have a lock with a lock period of 6 months.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createInvestorTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyCrowdsale returns (bool)
{
}
/**
* @dev Creates locks for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the owner of the contract;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The team members will have two locks with 1 and 2 years lock period, each having half of the amount.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createTeamTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyOwner returns (bool)
{
}
/**
* @dev Revokes the lock for the provided _beneficiary and _id.
* The revoke can be peformed only if:
* - the sender is the owner of the contract;
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock is revokable;
* - the lock was not released.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function revokeTokenTimelock(
address _beneficiary,
uint256 _id)
external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id)
{
}
/**
* @dev Returns the number locks of the provided _beneficiary.
* @param _beneficiary Address owning the locks.
*/
function getTokenTimelockCount(address _beneficiary) view external returns (uint) {
}
/**
* @dev Returns the details of the lock referenced by the provided _beneficiary and _id.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns (
uint256 _amount,
uint256 _releaseTime,
bool _released,
bool _revocable,
bool _revoked)
{
}
/**
* @dev Changes the beneficiary of the _id'th lock of the sender with the provided newBeneficiary.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* @param _id id of the lock.
* @param _newBeneficiary Address of the new beneficiary.
*/
function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) {
}
/**
* @dev Releases the tokens for the calling sender and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _id id of the lock.
*/
function release(uint256 _id) external {
}
/**
* @dev Releases the tokens for the provided _beneficiary and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) {
}
}
| !tokenTimeLocks[_beneficiary][_id].revoked | 319,214 | !tokenTimeLocks[_beneficiary][_id].revoked |
null | /**
* @title TokenTimelock Controller
* @dev This contract allows to create/read/revoke TokenTimelock contracts and to claim the amounts vested.
**/
contract TokenTimelockController is Ownable {
using SafeMath for uint;
struct TokenTimelock {
uint256 amount;
uint256 releaseTime;
bool released;
bool revocable;
bool revoked;
}
event TokenTimelockCreated(
address indexed beneficiary,
uint256 releaseTime,
bool revocable,
uint256 amount
);
event TokenTimelockRevoked(
address indexed beneficiary
);
event TokenTimelockBeneficiaryChanged(
address indexed previousBeneficiary,
address indexed newBeneficiary
);
event TokenTimelockReleased(
address indexed beneficiary,
uint256 amount
);
uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days;
uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days;
uint256 public constant INVESTOR_LOCK_DURATION = 6 * 30 days;
mapping (address => TokenTimelock[]) tokenTimeLocks;
ERC20 public token;
address public crowdsale;
bool public activated;
/// @notice Constructor for TokenTimelock Controller
constructor(ERC20 _token) public {
}
modifier onlyCrowdsale() {
}
modifier onlyWhenActivated() {
}
modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) {
}
/**
* @dev Function to set the crowdsale address
* @param _crowdsale address The address of the crowdsale.
*/
function setCrowdsale(address _crowdsale) external onlyOwner {
}
/**
* @dev Function to activate the controller.
* It can be called only by the crowdsale address.
*/
function activate() external onlyCrowdsale {
}
/**
* @dev Creates a lock for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the address of the crowdsale;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The investors will have a lock with a lock period of 6 months.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createInvestorTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyCrowdsale returns (bool)
{
require(_beneficiary != address(0) && _amount > 0);
require(_tokenHolder != address(0));
TokenTimelock memory tokenLock = TokenTimelock(
_amount,
_start.add(INVESTOR_LOCK_DURATION),
false,
false,
false
);
tokenTimeLocks[_beneficiary].push(tokenLock);
require(<FILL_ME>)
emit TokenTimelockCreated(
_beneficiary,
tokenLock.releaseTime,
false,
_amount);
return true;
}
/**
* @dev Creates locks for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the owner of the contract;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The team members will have two locks with 1 and 2 years lock period, each having half of the amount.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createTeamTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyOwner returns (bool)
{
}
/**
* @dev Revokes the lock for the provided _beneficiary and _id.
* The revoke can be peformed only if:
* - the sender is the owner of the contract;
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock is revokable;
* - the lock was not released.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function revokeTokenTimelock(
address _beneficiary,
uint256 _id)
external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id)
{
}
/**
* @dev Returns the number locks of the provided _beneficiary.
* @param _beneficiary Address owning the locks.
*/
function getTokenTimelockCount(address _beneficiary) view external returns (uint) {
}
/**
* @dev Returns the details of the lock referenced by the provided _beneficiary and _id.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns (
uint256 _amount,
uint256 _releaseTime,
bool _released,
bool _revocable,
bool _revoked)
{
}
/**
* @dev Changes the beneficiary of the _id'th lock of the sender with the provided newBeneficiary.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* @param _id id of the lock.
* @param _newBeneficiary Address of the new beneficiary.
*/
function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) {
}
/**
* @dev Releases the tokens for the calling sender and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _id id of the lock.
*/
function release(uint256 _id) external {
}
/**
* @dev Releases the tokens for the provided _beneficiary and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) {
}
}
| token.transferFrom(_tokenHolder,this,_amount) | 319,214 | token.transferFrom(_tokenHolder,this,_amount) |
null | /**
* @title TokenTimelock Controller
* @dev This contract allows to create/read/revoke TokenTimelock contracts and to claim the amounts vested.
**/
contract TokenTimelockController is Ownable {
using SafeMath for uint;
struct TokenTimelock {
uint256 amount;
uint256 releaseTime;
bool released;
bool revocable;
bool revoked;
}
event TokenTimelockCreated(
address indexed beneficiary,
uint256 releaseTime,
bool revocable,
uint256 amount
);
event TokenTimelockRevoked(
address indexed beneficiary
);
event TokenTimelockBeneficiaryChanged(
address indexed previousBeneficiary,
address indexed newBeneficiary
);
event TokenTimelockReleased(
address indexed beneficiary,
uint256 amount
);
uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days;
uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days;
uint256 public constant INVESTOR_LOCK_DURATION = 6 * 30 days;
mapping (address => TokenTimelock[]) tokenTimeLocks;
ERC20 public token;
address public crowdsale;
bool public activated;
/// @notice Constructor for TokenTimelock Controller
constructor(ERC20 _token) public {
}
modifier onlyCrowdsale() {
}
modifier onlyWhenActivated() {
}
modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) {
}
/**
* @dev Function to set the crowdsale address
* @param _crowdsale address The address of the crowdsale.
*/
function setCrowdsale(address _crowdsale) external onlyOwner {
}
/**
* @dev Function to activate the controller.
* It can be called only by the crowdsale address.
*/
function activate() external onlyCrowdsale {
}
/**
* @dev Creates a lock for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the address of the crowdsale;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The investors will have a lock with a lock period of 6 months.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createInvestorTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyCrowdsale returns (bool)
{
}
/**
* @dev Creates locks for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the owner of the contract;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The team members will have two locks with 1 and 2 years lock period, each having half of the amount.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createTeamTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyOwner returns (bool)
{
}
/**
* @dev Revokes the lock for the provided _beneficiary and _id.
* The revoke can be peformed only if:
* - the sender is the owner of the contract;
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock is revokable;
* - the lock was not released.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function revokeTokenTimelock(
address _beneficiary,
uint256 _id)
external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id)
{
require(<FILL_ME>)
require(!tokenTimeLocks[_beneficiary][_id].released);
TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id];
tokenLock.revoked = true;
require(token.transfer(owner, tokenLock.amount));
emit TokenTimelockRevoked(_beneficiary);
}
/**
* @dev Returns the number locks of the provided _beneficiary.
* @param _beneficiary Address owning the locks.
*/
function getTokenTimelockCount(address _beneficiary) view external returns (uint) {
}
/**
* @dev Returns the details of the lock referenced by the provided _beneficiary and _id.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns (
uint256 _amount,
uint256 _releaseTime,
bool _released,
bool _revocable,
bool _revoked)
{
}
/**
* @dev Changes the beneficiary of the _id'th lock of the sender with the provided newBeneficiary.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* @param _id id of the lock.
* @param _newBeneficiary Address of the new beneficiary.
*/
function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) {
}
/**
* @dev Releases the tokens for the calling sender and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _id id of the lock.
*/
function release(uint256 _id) external {
}
/**
* @dev Releases the tokens for the provided _beneficiary and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) {
}
}
| tokenTimeLocks[_beneficiary][_id].revocable | 319,214 | tokenTimeLocks[_beneficiary][_id].revocable |
null | /**
* @title TokenTimelock Controller
* @dev This contract allows to create/read/revoke TokenTimelock contracts and to claim the amounts vested.
**/
contract TokenTimelockController is Ownable {
using SafeMath for uint;
struct TokenTimelock {
uint256 amount;
uint256 releaseTime;
bool released;
bool revocable;
bool revoked;
}
event TokenTimelockCreated(
address indexed beneficiary,
uint256 releaseTime,
bool revocable,
uint256 amount
);
event TokenTimelockRevoked(
address indexed beneficiary
);
event TokenTimelockBeneficiaryChanged(
address indexed previousBeneficiary,
address indexed newBeneficiary
);
event TokenTimelockReleased(
address indexed beneficiary,
uint256 amount
);
uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days;
uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days;
uint256 public constant INVESTOR_LOCK_DURATION = 6 * 30 days;
mapping (address => TokenTimelock[]) tokenTimeLocks;
ERC20 public token;
address public crowdsale;
bool public activated;
/// @notice Constructor for TokenTimelock Controller
constructor(ERC20 _token) public {
}
modifier onlyCrowdsale() {
}
modifier onlyWhenActivated() {
}
modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) {
}
/**
* @dev Function to set the crowdsale address
* @param _crowdsale address The address of the crowdsale.
*/
function setCrowdsale(address _crowdsale) external onlyOwner {
}
/**
* @dev Function to activate the controller.
* It can be called only by the crowdsale address.
*/
function activate() external onlyCrowdsale {
}
/**
* @dev Creates a lock for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the address of the crowdsale;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The investors will have a lock with a lock period of 6 months.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createInvestorTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyCrowdsale returns (bool)
{
}
/**
* @dev Creates locks for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the owner of the contract;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The team members will have two locks with 1 and 2 years lock period, each having half of the amount.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createTeamTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyOwner returns (bool)
{
}
/**
* @dev Revokes the lock for the provided _beneficiary and _id.
* The revoke can be peformed only if:
* - the sender is the owner of the contract;
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock is revokable;
* - the lock was not released.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function revokeTokenTimelock(
address _beneficiary,
uint256 _id)
external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id)
{
require(tokenTimeLocks[_beneficiary][_id].revocable);
require(<FILL_ME>)
TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id];
tokenLock.revoked = true;
require(token.transfer(owner, tokenLock.amount));
emit TokenTimelockRevoked(_beneficiary);
}
/**
* @dev Returns the number locks of the provided _beneficiary.
* @param _beneficiary Address owning the locks.
*/
function getTokenTimelockCount(address _beneficiary) view external returns (uint) {
}
/**
* @dev Returns the details of the lock referenced by the provided _beneficiary and _id.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns (
uint256 _amount,
uint256 _releaseTime,
bool _released,
bool _revocable,
bool _revoked)
{
}
/**
* @dev Changes the beneficiary of the _id'th lock of the sender with the provided newBeneficiary.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* @param _id id of the lock.
* @param _newBeneficiary Address of the new beneficiary.
*/
function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) {
}
/**
* @dev Releases the tokens for the calling sender and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _id id of the lock.
*/
function release(uint256 _id) external {
}
/**
* @dev Releases the tokens for the provided _beneficiary and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) {
}
}
| !tokenTimeLocks[_beneficiary][_id].released | 319,214 | !tokenTimeLocks[_beneficiary][_id].released |
null | /**
* @title TokenTimelock Controller
* @dev This contract allows to create/read/revoke TokenTimelock contracts and to claim the amounts vested.
**/
contract TokenTimelockController is Ownable {
using SafeMath for uint;
struct TokenTimelock {
uint256 amount;
uint256 releaseTime;
bool released;
bool revocable;
bool revoked;
}
event TokenTimelockCreated(
address indexed beneficiary,
uint256 releaseTime,
bool revocable,
uint256 amount
);
event TokenTimelockRevoked(
address indexed beneficiary
);
event TokenTimelockBeneficiaryChanged(
address indexed previousBeneficiary,
address indexed newBeneficiary
);
event TokenTimelockReleased(
address indexed beneficiary,
uint256 amount
);
uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days;
uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days;
uint256 public constant INVESTOR_LOCK_DURATION = 6 * 30 days;
mapping (address => TokenTimelock[]) tokenTimeLocks;
ERC20 public token;
address public crowdsale;
bool public activated;
/// @notice Constructor for TokenTimelock Controller
constructor(ERC20 _token) public {
}
modifier onlyCrowdsale() {
}
modifier onlyWhenActivated() {
}
modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) {
}
/**
* @dev Function to set the crowdsale address
* @param _crowdsale address The address of the crowdsale.
*/
function setCrowdsale(address _crowdsale) external onlyOwner {
}
/**
* @dev Function to activate the controller.
* It can be called only by the crowdsale address.
*/
function activate() external onlyCrowdsale {
}
/**
* @dev Creates a lock for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the address of the crowdsale;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The investors will have a lock with a lock period of 6 months.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createInvestorTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyCrowdsale returns (bool)
{
}
/**
* @dev Creates locks for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the owner of the contract;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The team members will have two locks with 1 and 2 years lock period, each having half of the amount.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createTeamTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyOwner returns (bool)
{
}
/**
* @dev Revokes the lock for the provided _beneficiary and _id.
* The revoke can be peformed only if:
* - the sender is the owner of the contract;
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock is revokable;
* - the lock was not released.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function revokeTokenTimelock(
address _beneficiary,
uint256 _id)
external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id)
{
require(tokenTimeLocks[_beneficiary][_id].revocable);
require(!tokenTimeLocks[_beneficiary][_id].released);
TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id];
tokenLock.revoked = true;
require(<FILL_ME>)
emit TokenTimelockRevoked(_beneficiary);
}
/**
* @dev Returns the number locks of the provided _beneficiary.
* @param _beneficiary Address owning the locks.
*/
function getTokenTimelockCount(address _beneficiary) view external returns (uint) {
}
/**
* @dev Returns the details of the lock referenced by the provided _beneficiary and _id.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns (
uint256 _amount,
uint256 _releaseTime,
bool _released,
bool _revocable,
bool _revoked)
{
}
/**
* @dev Changes the beneficiary of the _id'th lock of the sender with the provided newBeneficiary.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* @param _id id of the lock.
* @param _newBeneficiary Address of the new beneficiary.
*/
function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) {
}
/**
* @dev Releases the tokens for the calling sender and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _id id of the lock.
*/
function release(uint256 _id) external {
}
/**
* @dev Releases the tokens for the provided _beneficiary and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) {
}
}
| token.transfer(owner,tokenLock.amount) | 319,214 | token.transfer(owner,tokenLock.amount) |
null | /**
* @title TokenTimelock Controller
* @dev This contract allows to create/read/revoke TokenTimelock contracts and to claim the amounts vested.
**/
contract TokenTimelockController is Ownable {
using SafeMath for uint;
struct TokenTimelock {
uint256 amount;
uint256 releaseTime;
bool released;
bool revocable;
bool revoked;
}
event TokenTimelockCreated(
address indexed beneficiary,
uint256 releaseTime,
bool revocable,
uint256 amount
);
event TokenTimelockRevoked(
address indexed beneficiary
);
event TokenTimelockBeneficiaryChanged(
address indexed previousBeneficiary,
address indexed newBeneficiary
);
event TokenTimelockReleased(
address indexed beneficiary,
uint256 amount
);
uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days;
uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days;
uint256 public constant INVESTOR_LOCK_DURATION = 6 * 30 days;
mapping (address => TokenTimelock[]) tokenTimeLocks;
ERC20 public token;
address public crowdsale;
bool public activated;
/// @notice Constructor for TokenTimelock Controller
constructor(ERC20 _token) public {
}
modifier onlyCrowdsale() {
}
modifier onlyWhenActivated() {
}
modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) {
}
/**
* @dev Function to set the crowdsale address
* @param _crowdsale address The address of the crowdsale.
*/
function setCrowdsale(address _crowdsale) external onlyOwner {
}
/**
* @dev Function to activate the controller.
* It can be called only by the crowdsale address.
*/
function activate() external onlyCrowdsale {
}
/**
* @dev Creates a lock for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the address of the crowdsale;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The investors will have a lock with a lock period of 6 months.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createInvestorTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyCrowdsale returns (bool)
{
}
/**
* @dev Creates locks for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the owner of the contract;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The team members will have two locks with 1 and 2 years lock period, each having half of the amount.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createTeamTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyOwner returns (bool)
{
}
/**
* @dev Revokes the lock for the provided _beneficiary and _id.
* The revoke can be peformed only if:
* - the sender is the owner of the contract;
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock is revokable;
* - the lock was not released.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function revokeTokenTimelock(
address _beneficiary,
uint256 _id)
external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id)
{
}
/**
* @dev Returns the number locks of the provided _beneficiary.
* @param _beneficiary Address owning the locks.
*/
function getTokenTimelockCount(address _beneficiary) view external returns (uint) {
}
/**
* @dev Returns the details of the lock referenced by the provided _beneficiary and _id.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns (
uint256 _amount,
uint256 _releaseTime,
bool _released,
bool _revocable,
bool _revoked)
{
}
/**
* @dev Changes the beneficiary of the _id'th lock of the sender with the provided newBeneficiary.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* @param _id id of the lock.
* @param _newBeneficiary Address of the new beneficiary.
*/
function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) {
}
/**
* @dev Releases the tokens for the calling sender and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _id id of the lock.
*/
function release(uint256 _id) external {
}
/**
* @dev Releases the tokens for the provided _beneficiary and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) {
TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id];
require(<FILL_ME>)
// solium-disable-next-line security/no-block-members
require(block.timestamp >= tokenLock.releaseTime);
tokenLock.released = true;
require(token.transfer(_beneficiary, tokenLock.amount));
emit TokenTimelockReleased(_beneficiary, tokenLock.amount);
}
}
| !tokenLock.released | 319,214 | !tokenLock.released |
null | /**
* @title TokenTimelock Controller
* @dev This contract allows to create/read/revoke TokenTimelock contracts and to claim the amounts vested.
**/
contract TokenTimelockController is Ownable {
using SafeMath for uint;
struct TokenTimelock {
uint256 amount;
uint256 releaseTime;
bool released;
bool revocable;
bool revoked;
}
event TokenTimelockCreated(
address indexed beneficiary,
uint256 releaseTime,
bool revocable,
uint256 amount
);
event TokenTimelockRevoked(
address indexed beneficiary
);
event TokenTimelockBeneficiaryChanged(
address indexed previousBeneficiary,
address indexed newBeneficiary
);
event TokenTimelockReleased(
address indexed beneficiary,
uint256 amount
);
uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days;
uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days;
uint256 public constant INVESTOR_LOCK_DURATION = 6 * 30 days;
mapping (address => TokenTimelock[]) tokenTimeLocks;
ERC20 public token;
address public crowdsale;
bool public activated;
/// @notice Constructor for TokenTimelock Controller
constructor(ERC20 _token) public {
}
modifier onlyCrowdsale() {
}
modifier onlyWhenActivated() {
}
modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) {
}
/**
* @dev Function to set the crowdsale address
* @param _crowdsale address The address of the crowdsale.
*/
function setCrowdsale(address _crowdsale) external onlyOwner {
}
/**
* @dev Function to activate the controller.
* It can be called only by the crowdsale address.
*/
function activate() external onlyCrowdsale {
}
/**
* @dev Creates a lock for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the address of the crowdsale;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The investors will have a lock with a lock period of 6 months.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createInvestorTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyCrowdsale returns (bool)
{
}
/**
* @dev Creates locks for the provided _beneficiary with the provided amount
* The creation can be peformed only if:
* - the sender is the owner of the contract;
* - the _beneficiary and _tokenHolder are valid addresses;
* - the _amount is greater than 0 and was appoved by the _tokenHolder prior to the transaction.
* The team members will have two locks with 1 and 2 years lock period, each having half of the amount.
* @param _beneficiary Address that will own the lock.
* @param _amount the amount of the locked tokens.
* @param _start when the lock should start.
* @param _tokenHolder the account that approved the amount for this contract.
*/
function createTeamTokenTimeLock(
address _beneficiary,
uint256 _amount,
uint256 _start,
address _tokenHolder
) external onlyOwner returns (bool)
{
}
/**
* @dev Revokes the lock for the provided _beneficiary and _id.
* The revoke can be peformed only if:
* - the sender is the owner of the contract;
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock is revokable;
* - the lock was not released.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function revokeTokenTimelock(
address _beneficiary,
uint256 _id)
external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id)
{
}
/**
* @dev Returns the number locks of the provided _beneficiary.
* @param _beneficiary Address owning the locks.
*/
function getTokenTimelockCount(address _beneficiary) view external returns (uint) {
}
/**
* @dev Returns the details of the lock referenced by the provided _beneficiary and _id.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns (
uint256 _amount,
uint256 _releaseTime,
bool _released,
bool _revocable,
bool _revoked)
{
}
/**
* @dev Changes the beneficiary of the _id'th lock of the sender with the provided newBeneficiary.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* @param _id id of the lock.
* @param _newBeneficiary Address of the new beneficiary.
*/
function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) {
}
/**
* @dev Releases the tokens for the calling sender and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the sender and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _id id of the lock.
*/
function release(uint256 _id) external {
}
/**
* @dev Releases the tokens for the provided _beneficiary and _id.
* The release can be peformed only if:
* - the controller was activated by the crowdsale contract;
* - the _beneficiary and _id reference a valid lock;
* - the lock was not revoked;
* - the lock was not released before;
* - the lock period has passed.
* @param _beneficiary Address owning the lock.
* @param _id id of the lock.
*/
function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) {
TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id];
require(!tokenLock.released);
// solium-disable-next-line security/no-block-members
require(block.timestamp >= tokenLock.releaseTime);
tokenLock.released = true;
require(<FILL_ME>)
emit TokenTimelockReleased(_beneficiary, tokenLock.amount);
}
}
| token.transfer(_beneficiary,tokenLock.amount) | 319,214 | token.transfer(_beneficiary,tokenLock.amount) |
"Could not transfer tokens." | pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract Pool2 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfilend token contract address
address public tokenAddress;
address public liquiditytoken1;
// reward rate % per year
uint public rewardRate = 60000;
uint public rewardInterval = 365 days;
// staking fee percent
uint public stakingFeeRate = 0;
// unstaking fee percent
uint public unstakingFeeRate = 0;
// unstaking possible Time
uint public PossibleUnstakeTime = 24 hours;
uint public totalClaimedRewards = 0;
uint private FundedTokens;
bool public stakingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
/*=============================ADMINISTRATIVE FUNCTIONS ==================================*/
function setTokenAddresses(address _tokenAddr, address _liquidityAddr) public onlyOwner returns(bool){
}
function stakingFeeRateSet(uint _stakingFeeRate, uint _unstakingFeeRate) public onlyOwner returns(bool){
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
}
function possibleUnstakeTimeSet(uint _possibleUnstakeTime) public onlyOwner returns(bool){
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
}
function allowStaking(bool _status) public onlyOwner returns(bool){
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
}
function updateAccount(address account) private {
uint unclaimedDivs = getUnclaimedDivs(account);
if (unclaimedDivs > 0) {
require(<FILL_ME>)
totalEarnedTokens[account] = totalEarnedTokens[account].add(unclaimedDivs);
totalClaimedRewards = totalClaimedRewards.add(unclaimedDivs);
emit RewardsTransferred(account, unclaimedDivs);
}
lastClaimedTime[account] = now;
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
}
function getNumberOfHolders() public view returns (uint) {
}
function place(uint amountToStake) public {
}
function lift(uint amountToWithdraw) public {
}
function claimYields() public {
}
function getFundedTokens() public view returns (uint) {
}
}
| Token(tokenAddress).transfer(account,unclaimedDivs),"Could not transfer tokens." | 319,233 | Token(tokenAddress).transfer(account,unclaimedDivs) |
"Insufficient Token Allowance" | pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract Pool2 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfilend token contract address
address public tokenAddress;
address public liquiditytoken1;
// reward rate % per year
uint public rewardRate = 60000;
uint public rewardInterval = 365 days;
// staking fee percent
uint public stakingFeeRate = 0;
// unstaking fee percent
uint public unstakingFeeRate = 0;
// unstaking possible Time
uint public PossibleUnstakeTime = 24 hours;
uint public totalClaimedRewards = 0;
uint private FundedTokens;
bool public stakingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
/*=============================ADMINISTRATIVE FUNCTIONS ==================================*/
function setTokenAddresses(address _tokenAddr, address _liquidityAddr) public onlyOwner returns(bool){
}
function stakingFeeRateSet(uint _stakingFeeRate, uint _unstakingFeeRate) public onlyOwner returns(bool){
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
}
function possibleUnstakeTimeSet(uint _possibleUnstakeTime) public onlyOwner returns(bool){
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
}
function allowStaking(bool _status) public onlyOwner returns(bool){
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
}
function updateAccount(address account) private {
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
}
function getNumberOfHolders() public view returns (uint) {
}
function place(uint amountToStake) public {
require(stakingStatus == true, "Staking is not yet initialized");
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(<FILL_ME>)
updateAccount(msg.sender);
uint fee = amountToStake.mul(stakingFeeRate).div(1e4);
uint amountAfterFee = amountToStake.sub(fee);
require(Token(liquiditytoken1).transfer(admin, fee), "Could not transfer deposit fee.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = now;
}
}
function lift(uint amountToWithdraw) public {
}
function claimYields() public {
}
function getFundedTokens() public view returns (uint) {
}
}
| Token(liquiditytoken1).transferFrom(msg.sender,address(this),amountToStake),"Insufficient Token Allowance" | 319,233 | Token(liquiditytoken1).transferFrom(msg.sender,address(this),amountToStake) |
"Could not transfer deposit fee." | pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract Pool2 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfilend token contract address
address public tokenAddress;
address public liquiditytoken1;
// reward rate % per year
uint public rewardRate = 60000;
uint public rewardInterval = 365 days;
// staking fee percent
uint public stakingFeeRate = 0;
// unstaking fee percent
uint public unstakingFeeRate = 0;
// unstaking possible Time
uint public PossibleUnstakeTime = 24 hours;
uint public totalClaimedRewards = 0;
uint private FundedTokens;
bool public stakingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
/*=============================ADMINISTRATIVE FUNCTIONS ==================================*/
function setTokenAddresses(address _tokenAddr, address _liquidityAddr) public onlyOwner returns(bool){
}
function stakingFeeRateSet(uint _stakingFeeRate, uint _unstakingFeeRate) public onlyOwner returns(bool){
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
}
function possibleUnstakeTimeSet(uint _possibleUnstakeTime) public onlyOwner returns(bool){
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
}
function allowStaking(bool _status) public onlyOwner returns(bool){
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
}
function updateAccount(address account) private {
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
}
function getNumberOfHolders() public view returns (uint) {
}
function place(uint amountToStake) public {
require(stakingStatus == true, "Staking is not yet initialized");
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(Token(liquiditytoken1).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
uint fee = amountToStake.mul(stakingFeeRate).div(1e4);
uint amountAfterFee = amountToStake.sub(fee);
require(<FILL_ME>)
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = now;
}
}
function lift(uint amountToWithdraw) public {
}
function claimYields() public {
}
function getFundedTokens() public view returns (uint) {
}
}
| Token(liquiditytoken1).transfer(admin,fee),"Could not transfer deposit fee." | 319,233 | Token(liquiditytoken1).transfer(admin,fee) |
"You have not staked for a while yet, kindly wait a bit more" | pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract Pool2 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfilend token contract address
address public tokenAddress;
address public liquiditytoken1;
// reward rate % per year
uint public rewardRate = 60000;
uint public rewardInterval = 365 days;
// staking fee percent
uint public stakingFeeRate = 0;
// unstaking fee percent
uint public unstakingFeeRate = 0;
// unstaking possible Time
uint public PossibleUnstakeTime = 24 hours;
uint public totalClaimedRewards = 0;
uint private FundedTokens;
bool public stakingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
/*=============================ADMINISTRATIVE FUNCTIONS ==================================*/
function setTokenAddresses(address _tokenAddr, address _liquidityAddr) public onlyOwner returns(bool){
}
function stakingFeeRateSet(uint _stakingFeeRate, uint _unstakingFeeRate) public onlyOwner returns(bool){
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
}
function possibleUnstakeTimeSet(uint _possibleUnstakeTime) public onlyOwner returns(bool){
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
}
function allowStaking(bool _status) public onlyOwner returns(bool){
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
}
function updateAccount(address account) private {
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
}
function getNumberOfHolders() public view returns (uint) {
}
function place(uint amountToStake) public {
}
function lift(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(<FILL_ME>)
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(unstakingFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(liquiditytoken1).transfer(admin, fee), "Could not transfer withdraw fee.");
require(Token(liquiditytoken1).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimYields() public {
}
function getFundedTokens() public view returns (uint) {
}
}
| now.sub(stakingTime[msg.sender])>PossibleUnstakeTime,"You have not staked for a while yet, kindly wait a bit more" | 319,233 | now.sub(stakingTime[msg.sender])>PossibleUnstakeTime |
"Could not transfer tokens." | pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
* (`UintSet`) are supported.
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract Pool2 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfilend token contract address
address public tokenAddress;
address public liquiditytoken1;
// reward rate % per year
uint public rewardRate = 60000;
uint public rewardInterval = 365 days;
// staking fee percent
uint public stakingFeeRate = 0;
// unstaking fee percent
uint public unstakingFeeRate = 0;
// unstaking possible Time
uint public PossibleUnstakeTime = 24 hours;
uint public totalClaimedRewards = 0;
uint private FundedTokens;
bool public stakingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
/*=============================ADMINISTRATIVE FUNCTIONS ==================================*/
function setTokenAddresses(address _tokenAddr, address _liquidityAddr) public onlyOwner returns(bool){
}
function stakingFeeRateSet(uint _stakingFeeRate, uint _unstakingFeeRate) public onlyOwner returns(bool){
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
}
function possibleUnstakeTimeSet(uint _possibleUnstakeTime) public onlyOwner returns(bool){
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
}
function allowStaking(bool _status) public onlyOwner returns(bool){
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
}
function updateAccount(address account) private {
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
}
function getNumberOfHolders() public view returns (uint) {
}
function place(uint amountToStake) public {
}
function lift(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(stakingTime[msg.sender]) > PossibleUnstakeTime, "You have not staked for a while yet, kindly wait a bit more");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(unstakingFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(liquiditytoken1).transfer(admin, fee), "Could not transfer withdraw fee.");
require(<FILL_ME>)
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function claimYields() public {
}
function getFundedTokens() public view returns (uint) {
}
}
| Token(liquiditytoken1).transfer(msg.sender,amountAfterFee),"Could not transfer tokens." | 319,233 | Token(liquiditytoken1).transfer(msg.sender,amountAfterFee) |
Errors.InsufficientTokenBalance | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Receiver.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "./DateTime.sol";
/* ========== ERRORS ========== */
library Errors {
string internal constant InvalidTimestamp = "invalid timestamp";
string internal constant InvalidInput = "invalid input provided";
string internal constant NoVestingSchedule =
"sender has not been registered for a vesting schedule";
string internal constant InsufficientTokenBalance =
"contract does not have enough tokens to distribute";
}
/* ========== DATA STRUCTURES ========== */
// @notice A vesting schedule for an individual address.
struct VestingSchedule {
uint256 lastClaim;
uint16 monthsRemaining;
uint32 tokensPerMonth;
}
contract Vesting is Ownable, ERC1155Receiver {
/* ========== EVENTS ========== */
event VestingTokensGranted(
address indexed to,
uint256 totalMonths,
uint256 tokensPerMonth
);
event VestedTokensClaimed(
address indexed by,
uint256 monthsClaimed,
uint256 amount
);
event VestingTokensRevoked(address indexed from);
event RewardTokenSet(address tokenAddress, uint256 tokenId);
event TokensWithdrawnFromContract(address indexed to, uint256 amount);
/* ========== STATE VARIABLES ========== */
address private _tokenAddress;
uint256 private _tokenId;
mapping(address => VestingSchedule) private _vestingSchedules;
/* ========== CONSTRUCTOR ========== */
constructor(address tokenAddress, uint256 tokenId) ERC1155Receiver() {
}
/* ========== MUTATIVE FUNCTIONS ========== */
// @notice Claim your vested tokens since last claiming timestamp.
function claimTokens() external returns (uint256 tokensToClaim) {
VestingSchedule storage userVestingSchedule = _vestingSchedules[msg.sender];
uint256 monthsPassed = DateTime.diffMonths(
_vestingSchedules[msg.sender].lastClaim,
block.timestamp
);
// use uint16 because we can not claim more than the months remaining. avoid overflow later when assumptions are more complex.
// explicit conversion here should be fine, since we already min() with a upscaled uint16 (monthsRemaining), so the range should fall within a single uint16
uint16 monthsClaimed = uint16(
Math.min(userVestingSchedule.monthsRemaining, monthsPassed)
);
if (monthsClaimed == 0) {
return 0;
} else {
tokensToClaim =
uint256(userVestingSchedule.tokensPerMonth) *
monthsClaimed;
}
IERC1155 token = IERC1155(_tokenAddress);
require(<FILL_ME>)
_vestingSchedules[msg.sender].lastClaim = block.timestamp;
_vestingSchedules[msg.sender].monthsRemaining =
_vestingSchedules[msg.sender].monthsRemaining -
monthsClaimed;
token.safeTransferFrom(
address(this),
msg.sender,
_tokenId,
tokensToClaim,
"Claiming vested tokens"
);
emit VestedTokensClaimed(msg.sender, monthsClaimed, tokensToClaim);
}
// @notice Grant vesting tokens to a specified address.
// @param toGrant Address to receive tokens on a vesting schedule.
// @param numberOfMonths Number of months to grant tokens for.
// @param tokensPerMonth Number of tokens to grant per month.
function grantVestingTokens(
address toGrant,
uint16 numberOfMonths,
uint32 tokensPerMonth
) external onlyOwner {
}
// @notice Owner can withdraw tokens deposited into the contract.
// @param count The number of tokens to withdraw.
function withdrawTokens(uint256 count) external onlyOwner {
}
// @notice Revoke vesting tokens from specified address.
// @param revokeAddress The address to revoke tokens from.
function revokeVestingTokens(address revokeAddress) external onlyOwner {
}
/*
* @notice Set the token to be used for vesting rewards.
* @dev Token must implement ERC1155.
* @param tokenAddress The address of the token contract.
* @param tokenId The id of the token.
*/
function setToken(address tokenAddress, uint256 id) external onlyOwner {
}
/* ========== VIEW FUNCTIONS ========== */
/*
* @notice Get the vested token address and ID.
*/
function getToken() external view returns (address, uint256) {
}
/*
* @notice Get the vesting schedule for a specified address.
* @param addr The address to get the schedule for.
*/
function getVestingSchedule(address addr)
external
view
returns (
uint256 timestamp,
uint16 monthsRemaining,
uint32 tokensPerMonth
)
{
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external pure override returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external pure override returns (bytes4) {
}
}
| token.balanceOf(address(this),_tokenId)>=tokensToClaim,Errors.InsufficientTokenBalance | 319,263 | token.balanceOf(address(this),_tokenId)>=tokensToClaim |
Errors.InsufficientTokenBalance | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Receiver.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "./DateTime.sol";
/* ========== ERRORS ========== */
library Errors {
string internal constant InvalidTimestamp = "invalid timestamp";
string internal constant InvalidInput = "invalid input provided";
string internal constant NoVestingSchedule =
"sender has not been registered for a vesting schedule";
string internal constant InsufficientTokenBalance =
"contract does not have enough tokens to distribute";
}
/* ========== DATA STRUCTURES ========== */
// @notice A vesting schedule for an individual address.
struct VestingSchedule {
uint256 lastClaim;
uint16 monthsRemaining;
uint32 tokensPerMonth;
}
contract Vesting is Ownable, ERC1155Receiver {
/* ========== EVENTS ========== */
event VestingTokensGranted(
address indexed to,
uint256 totalMonths,
uint256 tokensPerMonth
);
event VestedTokensClaimed(
address indexed by,
uint256 monthsClaimed,
uint256 amount
);
event VestingTokensRevoked(address indexed from);
event RewardTokenSet(address tokenAddress, uint256 tokenId);
event TokensWithdrawnFromContract(address indexed to, uint256 amount);
/* ========== STATE VARIABLES ========== */
address private _tokenAddress;
uint256 private _tokenId;
mapping(address => VestingSchedule) private _vestingSchedules;
/* ========== CONSTRUCTOR ========== */
constructor(address tokenAddress, uint256 tokenId) ERC1155Receiver() {
}
/* ========== MUTATIVE FUNCTIONS ========== */
// @notice Claim your vested tokens since last claiming timestamp.
function claimTokens() external returns (uint256 tokensToClaim) {
}
// @notice Grant vesting tokens to a specified address.
// @param toGrant Address to receive tokens on a vesting schedule.
// @param numberOfMonths Number of months to grant tokens for.
// @param tokensPerMonth Number of tokens to grant per month.
function grantVestingTokens(
address toGrant,
uint16 numberOfMonths,
uint32 tokensPerMonth
) external onlyOwner {
}
// @notice Owner can withdraw tokens deposited into the contract.
// @param count The number of tokens to withdraw.
function withdrawTokens(uint256 count) external onlyOwner {
IERC1155 token = IERC1155(_tokenAddress);
require(<FILL_ME>)
token.safeTransferFrom(
address(this),
msg.sender,
_tokenId,
count,
"Withdrawing tokens"
);
emit TokensWithdrawnFromContract(msg.sender, count);
}
// @notice Revoke vesting tokens from specified address.
// @param revokeAddress The address to revoke tokens from.
function revokeVestingTokens(address revokeAddress) external onlyOwner {
}
/*
* @notice Set the token to be used for vesting rewards.
* @dev Token must implement ERC1155.
* @param tokenAddress The address of the token contract.
* @param tokenId The id of the token.
*/
function setToken(address tokenAddress, uint256 id) external onlyOwner {
}
/* ========== VIEW FUNCTIONS ========== */
/*
* @notice Get the vested token address and ID.
*/
function getToken() external view returns (address, uint256) {
}
/*
* @notice Get the vesting schedule for a specified address.
* @param addr The address to get the schedule for.
*/
function getVestingSchedule(address addr)
external
view
returns (
uint256 timestamp,
uint16 monthsRemaining,
uint32 tokensPerMonth
)
{
}
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external pure override returns (bytes4) {
}
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external pure override returns (bytes4) {
}
}
| token.balanceOf(address(this),_tokenId)>=count,Errors.InsufficientTokenBalance | 319,263 | token.balanceOf(address(this),_tokenId)>=count |
"Only OGs can mint now!" | pragma solidity ^0.8.4;
//import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
//import "@openzeppelin/contracts/utils/Counters.sol";
//import "@openzeppelin/contracts/access/Ownable.sol";
//import './RandomlyAssigned.sol';
/*
,,,,,@@@@@@@@,,,,,,,,,,,,,
#@@@@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@@@@#
&@@@@@,. ,&@@@@@.. @& ..@@@@&, .@@@@@@&
/&@@&,. @@@#, &@@% .#@@@# .%@@@&/
.#@#/ &@@&, &@@% *&@&* (@@@@(
#/ %@@& %@@@@( @@%. ,&@@@
%@@& %@@@@( @@@( /@@&
@# %@@& %@@@@( @@% @@@@*
@@@@&, &@@&/ &@@% (@@&. (@@@%.
@@&#@@@( @@@%(. &@@% .%@@@/ .%@@@@*
@@% *&@@@@%. .%@@@@**, @& **@@@@%. *@@@@%(
@@% &@@@@@@... (%@@@@@@@@@@@@@@@@@%#.(@@@@@%/
@@% &@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
@@% ....,@@@@@@@@@@@@*...
@@@(
(@@(
@@@/
.@@@*
,@@@, #@@@@@@@@@@@#
*@@@# ., ,@@@/
(@@@/ .@@@*
(@@@%. *@@&,
&@@@@,. .&@@@(
#@@@@@@@&&&&&@@@@@@@
,,,,,,,,,,,
*/
contract YourSphynxCat is ERC721, Ownable, RandomlyAssigned {
using Strings for uint256;
using Counters for Counters.Counter;
mapping(address => bool) whitelistedAddresses;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public teamTokensMinted;
uint256 public cost = 10000000 gwei;
uint256 public maxSupply = 9099;
uint256 public maxMintAmountPerTx = 10;
bool public paused = false;
bool public revealed = false;
bool public ogmint = true;
uint256 private constant maxTeamCats = 99;
address private immutable _teamAddress =
0xD7c109808Ae28f6618D4596aFc91363521F4C070;
constructor() ERC721("YourSphynxCat", "YSC") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function addUser(address _addressToWhitelist) public onlyOwner {
}
modifier isWhitelisted(address _address) {
}
function verifyUser(address _whitelistedAddress) public view returns(bool) {
}
function addWhitelisted(address[] memory accounts)
public
onlyOwner
{
}
function checkOG() public view isWhitelisted(msg.sender) returns(bool){
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
if (ogmint == true) {
require(<FILL_ME>)
}
require(balanceOf(msg.sender)+_mintAmount <= 10, "Each wallet may only own 10 cats!");
require(msg.value >= cost * _mintAmount, "Insufficient funds!");
_mintLoop(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOG(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _mintRandomId(address to) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function devReserveTokens(uint256 count)
external
onlyOwner
ensureAvailabilityFor(count)
{
}
}
| checkOG()==true,"Only OGs can mint now!" | 319,284 | checkOG()==true |
"Each wallet may only own 10 cats!" | pragma solidity ^0.8.4;
//import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
//import "@openzeppelin/contracts/utils/Counters.sol";
//import "@openzeppelin/contracts/access/Ownable.sol";
//import './RandomlyAssigned.sol';
/*
,,,,,@@@@@@@@,,,,,,,,,,,,,
#@@@@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@@@@#
&@@@@@,. ,&@@@@@.. @& ..@@@@&, .@@@@@@&
/&@@&,. @@@#, &@@% .#@@@# .%@@@&/
.#@#/ &@@&, &@@% *&@&* (@@@@(
#/ %@@& %@@@@( @@%. ,&@@@
%@@& %@@@@( @@@( /@@&
@# %@@& %@@@@( @@% @@@@*
@@@@&, &@@&/ &@@% (@@&. (@@@%.
@@&#@@@( @@@%(. &@@% .%@@@/ .%@@@@*
@@% *&@@@@%. .%@@@@**, @& **@@@@%. *@@@@%(
@@% &@@@@@@... (%@@@@@@@@@@@@@@@@@%#.(@@@@@%/
@@% &@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
@@% ....,@@@@@@@@@@@@*...
@@@(
(@@(
@@@/
.@@@*
,@@@, #@@@@@@@@@@@#
*@@@# ., ,@@@/
(@@@/ .@@@*
(@@@%. *@@&,
&@@@@,. .&@@@(
#@@@@@@@&&&&&@@@@@@@
,,,,,,,,,,,
*/
contract YourSphynxCat is ERC721, Ownable, RandomlyAssigned {
using Strings for uint256;
using Counters for Counters.Counter;
mapping(address => bool) whitelistedAddresses;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public teamTokensMinted;
uint256 public cost = 10000000 gwei;
uint256 public maxSupply = 9099;
uint256 public maxMintAmountPerTx = 10;
bool public paused = false;
bool public revealed = false;
bool public ogmint = true;
uint256 private constant maxTeamCats = 99;
address private immutable _teamAddress =
0xD7c109808Ae28f6618D4596aFc91363521F4C070;
constructor() ERC721("YourSphynxCat", "YSC") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function addUser(address _addressToWhitelist) public onlyOwner {
}
modifier isWhitelisted(address _address) {
}
function verifyUser(address _whitelistedAddress) public view returns(bool) {
}
function addWhitelisted(address[] memory accounts)
public
onlyOwner
{
}
function checkOG() public view isWhitelisted(msg.sender) returns(bool){
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(!paused, "The contract is paused!");
if (ogmint == true) {
require(checkOG() == true, "Only OGs can mint now!");
}
require(<FILL_ME>)
require(msg.value >= cost * _mintAmount, "Insufficient funds!");
_mintLoop(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOG(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _mintRandomId(address to) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function devReserveTokens(uint256 count)
external
onlyOwner
ensureAvailabilityFor(count)
{
}
}
| balanceOf(msg.sender)+_mintAmount<=10,"Each wallet may only own 10 cats!" | 319,284 | balanceOf(msg.sender)+_mintAmount<=10 |
'Exceeds the reserved supply of team tokens' | pragma solidity ^0.8.4;
//import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
//import "@openzeppelin/contracts/utils/Counters.sol";
//import "@openzeppelin/contracts/access/Ownable.sol";
//import './RandomlyAssigned.sol';
/*
,,,,,@@@@@@@@,,,,,,,,,,,,,
#@@@@@@@@@@@@@@@@@@&@@@@@@@@@@@@@@@@@@#
&@@@@@,. ,&@@@@@.. @& ..@@@@&, .@@@@@@&
/&@@&,. @@@#, &@@% .#@@@# .%@@@&/
.#@#/ &@@&, &@@% *&@&* (@@@@(
#/ %@@& %@@@@( @@%. ,&@@@
%@@& %@@@@( @@@( /@@&
@# %@@& %@@@@( @@% @@@@*
@@@@&, &@@&/ &@@% (@@&. (@@@%.
@@&#@@@( @@@%(. &@@% .%@@@/ .%@@@@*
@@% *&@@@@%. .%@@@@**, @& **@@@@%. *@@@@%(
@@% &@@@@@@... (%@@@@@@@@@@@@@@@@@%#.(@@@@@%/
@@% &@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
@@% ....,@@@@@@@@@@@@*...
@@@(
(@@(
@@@/
.@@@*
,@@@, #@@@@@@@@@@@#
*@@@# ., ,@@@/
(@@@/ .@@@*
(@@@%. *@@&,
&@@@@,. .&@@@(
#@@@@@@@&&&&&@@@@@@@
,,,,,,,,,,,
*/
contract YourSphynxCat is ERC721, Ownable, RandomlyAssigned {
using Strings for uint256;
using Counters for Counters.Counter;
mapping(address => bool) whitelistedAddresses;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public teamTokensMinted;
uint256 public cost = 10000000 gwei;
uint256 public maxSupply = 9099;
uint256 public maxMintAmountPerTx = 10;
bool public paused = false;
bool public revealed = false;
bool public ogmint = true;
uint256 private constant maxTeamCats = 99;
address private immutable _teamAddress =
0xD7c109808Ae28f6618D4596aFc91363521F4C070;
constructor() ERC721("YourSphynxCat", "YSC") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function addUser(address _addressToWhitelist) public onlyOwner {
}
modifier isWhitelisted(address _address) {
}
function verifyUser(address _whitelistedAddress) public view returns(bool) {
}
function addWhitelisted(address[] memory accounts)
public
onlyOwner
{
}
function checkOG() public view isWhitelisted(msg.sender) returns(bool){
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOG(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _mintRandomId(address to) private {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function devReserveTokens(uint256 count)
external
onlyOwner
ensureAvailabilityFor(count)
{
require(<FILL_ME>)
for (uint256 i = 0; i < count; i++) {
_mintRandomId(_teamAddress);
}
teamTokensMinted += count;
}
}
| count+teamTokensMinted<=maxTeamCats,'Exceeds the reserved supply of team tokens' | 319,284 | count+teamTokensMinted<=maxTeamCats |
"The account is currently locked." | pragma solidity ^0.5.5;
import "./StandardToken.sol";
import "./MultiOwnable.sol";
/**
* @title Lockable token
*/
contract LockableToken is StandardToken, MultiOwnable {
bool public locked = true;
/**
* dev 락 = TRUE 이여도 거래 가능한 언락 계정
*/
mapping(address => bool) public unlockAddrs;
/**
* dev - 계정마다 lockValue만큼 락이 걸린다.
* dev - lockValue = 0 > limit이 없음
*/
mapping(address => uint256) public lockValues;
event Locked(bool locked, string note);
event LockedTo(address indexed addr, bool locked, string note);
event SetLockValue(address indexed addr, uint256 value, string note);
constructor() public {
}
modifier checkUnlock (address addr, uint256 value) {
require(<FILL_ME>)
require(balances[addr].sub(value) >= lockValues[addr], "Transferable limit exceeded. Check the status of the lock value.");
_;
}
function lock(string memory note) public onlyOwner {
}
function unlock(string memory note) public onlyOwner {
}
function lockTo(address addr, string memory note) public onlyOwner {
}
function unlockTo(address addr, string memory note) public onlyOwner {
}
function setLockValue(address addr, uint256 value, string memory note) public onlyOwner {
}
/**
* dev 이체 가능 금액 체크
*/
function getMyUnlockValue() public view returns (uint256) {
}
function transfer(address to, uint256 value) public checkUnlock(msg.sender, value) returns (bool) {
}
function transferFrom(address from, address to, uint256 value) public checkUnlock(from, value) returns (bool) {
}
}
| !locked||unlockAddrs[addr],"The account is currently locked." | 319,294 | !locked||unlockAddrs[addr] |
"Transferable limit exceeded. Check the status of the lock value." | pragma solidity ^0.5.5;
import "./StandardToken.sol";
import "./MultiOwnable.sol";
/**
* @title Lockable token
*/
contract LockableToken is StandardToken, MultiOwnable {
bool public locked = true;
/**
* dev 락 = TRUE 이여도 거래 가능한 언락 계정
*/
mapping(address => bool) public unlockAddrs;
/**
* dev - 계정마다 lockValue만큼 락이 걸린다.
* dev - lockValue = 0 > limit이 없음
*/
mapping(address => uint256) public lockValues;
event Locked(bool locked, string note);
event LockedTo(address indexed addr, bool locked, string note);
event SetLockValue(address indexed addr, uint256 value, string note);
constructor() public {
}
modifier checkUnlock (address addr, uint256 value) {
require(!locked || unlockAddrs[addr], "The account is currently locked.");
require(<FILL_ME>)
_;
}
function lock(string memory note) public onlyOwner {
}
function unlock(string memory note) public onlyOwner {
}
function lockTo(address addr, string memory note) public onlyOwner {
}
function unlockTo(address addr, string memory note) public onlyOwner {
}
function setLockValue(address addr, uint256 value, string memory note) public onlyOwner {
}
/**
* dev 이체 가능 금액 체크
*/
function getMyUnlockValue() public view returns (uint256) {
}
function transfer(address to, uint256 value) public checkUnlock(msg.sender, value) returns (bool) {
}
function transferFrom(address from, address to, uint256 value) public checkUnlock(from, value) returns (bool) {
}
}
| balances[addr].sub(value)>=lockValues[addr],"Transferable limit exceeded. Check the status of the lock value." | 319,294 | balances[addr].sub(value)>=lockValues[addr] |
"ds-token-insufficient-approval" | // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.5.2;
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
address public authority;
address public owner;
constructor() public {
}
function setOwner(address owner_)
public
onlyOwner
{
}
function setAuthority(address authority_)
public
onlyOwner
{
}
modifier auth {
}
modifier onlyOwner {
}
function isOwner(address src) public view returns (bool) {
}
function isAuthorized(address src) internal view returns (bool) {
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
}
function stop() public onlyOwner note {
}
function start() public onlyOwner note {
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
}
function totalSupply() public view returns (uint) {
}
function balanceOf(address src) public view returns (uint) {
}
function allowance(address src, address guy) public view returns (uint) {
}
function transfer(address dst, uint wad) public returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
require(<FILL_ME>)
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(_balances[src] >= wad, "ds-token-insufficient-balance");
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
}
}
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public name = "";
bytes32 public symbol;
uint256 public decimals = 18;
constructor(bytes32 symbol_) public {
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function setName(bytes32 name_) public onlyOwner {
}
function approvex(address guy) public stoppable returns (bool) {
}
function approve(address guy, uint wad) public stoppable returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
}
function mint(address guy, uint wad) public auth stoppable {
}
function burn(address guy, uint wad) public auth stoppable {
}
function _mint(address guy, uint wad) internal {
}
function _burn(address guy, uint wad) internal {
}
}
| _approvals[src][msg.sender]>=wad,"ds-token-insufficient-approval" | 319,340 | _approvals[src][msg.sender]>=wad |
"ds-token-insufficient-balance" | // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.5.2;
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
address public authority;
address public owner;
constructor() public {
}
function setOwner(address owner_)
public
onlyOwner
{
}
function setAuthority(address authority_)
public
onlyOwner
{
}
modifier auth {
}
modifier onlyOwner {
}
function isOwner(address src) public view returns (bool) {
}
function isAuthorized(address src) internal view returns (bool) {
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
}
function stop() public onlyOwner note {
}
function start() public onlyOwner note {
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
}
function totalSupply() public view returns (uint) {
}
function balanceOf(address src) public view returns (uint) {
}
function allowance(address src, address guy) public view returns (uint) {
}
function transfer(address dst, uint wad) public returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
require(_approvals[src][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
require(<FILL_ME>)
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
}
}
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public name = "";
bytes32 public symbol;
uint256 public decimals = 18;
constructor(bytes32 symbol_) public {
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function setName(bytes32 name_) public onlyOwner {
}
function approvex(address guy) public stoppable returns (bool) {
}
function approve(address guy, uint wad) public stoppable returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
}
function mint(address guy, uint wad) public auth stoppable {
}
function burn(address guy, uint wad) public auth stoppable {
}
function _mint(address guy, uint wad) internal {
}
function _burn(address guy, uint wad) internal {
}
}
| _balances[src]>=wad,"ds-token-insufficient-balance" | 319,340 | _balances[src]>=wad |
null | // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.5.2;
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
address public authority;
address public owner;
constructor() public {
}
function setOwner(address owner_)
public
onlyOwner
{
}
function setAuthority(address authority_)
public
onlyOwner
{
}
modifier auth {
}
modifier onlyOwner {
}
function isOwner(address src) public view returns (bool) {
}
function isAuthorized(address src) internal view returns (bool) {
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
}
function stop() public onlyOwner note {
}
function start() public onlyOwner note {
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
}
function totalSupply() public view returns (uint) {
}
function balanceOf(address src) public view returns (uint) {
}
function allowance(address src, address guy) public view returns (uint) {
}
function transfer(address dst, uint wad) public returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
}
function approve(address guy, uint wad) public returns (bool) {
}
}
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public name = "";
bytes32 public symbol;
uint256 public decimals = 18;
constructor(bytes32 symbol_) public {
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function setName(bytes32 name_) public onlyOwner {
}
function approvex(address guy) public stoppable returns (bool) {
}
function approve(address guy, uint wad) public stoppable returns (bool) {
require(<FILL_ME>) //take care of re-approve.
return super.approve(guy, wad);
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
}
function mint(address guy, uint wad) public auth stoppable {
}
function burn(address guy, uint wad) public auth stoppable {
}
function _mint(address guy, uint wad) internal {
}
function _burn(address guy, uint wad) internal {
}
}
| _approvals[msg.sender][guy]==0||wad==0 | 319,340 | _approvals[msg.sender][guy]==0||wad==0 |
"ds-token-insufficient-approval" | // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.5.2;
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
address public authority;
address public owner;
constructor() public {
}
function setOwner(address owner_)
public
onlyOwner
{
}
function setAuthority(address authority_)
public
onlyOwner
{
}
modifier auth {
}
modifier onlyOwner {
}
function isOwner(address src) public view returns (bool) {
}
function isAuthorized(address src) internal view returns (bool) {
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
}
function stop() public onlyOwner note {
}
function start() public onlyOwner note {
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
}
function totalSupply() public view returns (uint) {
}
function balanceOf(address src) public view returns (uint) {
}
function allowance(address src, address guy) public view returns (uint) {
}
function transfer(address dst, uint wad) public returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
}
function approve(address guy, uint wad) public returns (bool) {
}
}
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public name = "";
bytes32 public symbol;
uint256 public decimals = 18;
constructor(bytes32 symbol_) public {
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function setName(bytes32 name_) public onlyOwner {
}
function approvex(address guy) public stoppable returns (bool) {
}
function approve(address guy, uint wad) public stoppable returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
}
function mint(address guy, uint wad) public auth stoppable {
}
function burn(address guy, uint wad) public auth stoppable {
}
function _mint(address guy, uint wad) internal {
}
function _burn(address guy, uint wad) internal {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
require(<FILL_ME>)
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
require(_balances[guy] >= wad, "ds-token-insufficient-balance");
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
}
}
| _approvals[guy][msg.sender]>=wad,"ds-token-insufficient-approval" | 319,340 | _approvals[guy][msg.sender]>=wad |
"ds-token-insufficient-balance" | // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.5.2;
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
address public authority;
address public owner;
constructor() public {
}
function setOwner(address owner_)
public
onlyOwner
{
}
function setAuthority(address authority_)
public
onlyOwner
{
}
modifier auth {
}
modifier onlyOwner {
}
function isOwner(address src) public view returns (bool) {
}
function isAuthorized(address src) internal view returns (bool) {
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax
) anonymous;
modifier note {
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
}
function stop() public onlyOwner note {
}
function start() public onlyOwner note {
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
}
function totalSupply() public view returns (uint) {
}
function balanceOf(address src) public view returns (uint) {
}
function allowance(address src, address guy) public view returns (uint) {
}
function transfer(address dst, uint wad) public returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
}
function approve(address guy, uint wad) public returns (bool) {
}
}
contract DSToken is DSTokenBase(0), DSStop {
bytes32 public name = "";
bytes32 public symbol;
uint256 public decimals = 18;
constructor(bytes32 symbol_) public {
}
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function setName(bytes32 name_) public onlyOwner {
}
function approvex(address guy) public stoppable returns (bool) {
}
function approve(address guy, uint wad) public stoppable returns (bool) {
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
}
function mint(address guy, uint wad) public auth stoppable {
}
function burn(address guy, uint wad) public auth stoppable {
}
function _mint(address guy, uint wad) internal {
}
function _burn(address guy, uint wad) internal {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
require(_approvals[guy][msg.sender] >= wad, "ds-token-insufficient-approval");
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
require(<FILL_ME>)
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
}
}
| _balances[guy]>=wad,"ds-token-insufficient-balance" | 319,340 | _balances[guy]>=wad |
"This address already minted" | // contracts/StakerNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "./merkle/MerkleDistributor.sol";
contract SniperNFT is ERC721Enumerable, Ownable {
// bool
bool public _isMintingLive = false;
bool public _isAllowListRequired = true;
// addresses
address _owner;
address private feeReceiver;
// integers
uint256 public _totalSupply = 0;
uint256 public MAX_SUPPLY = 999;
uint256 public GIFT_SNIPER_SUPPLY = 0;
uint256 public SILVER_SNIPER_SUPPLY = 0;
uint256 public GOLD_SNIPER_SUPPLY = 0;
uint256 public MAX_GIFT_SNIPERS = 30;
uint256 public MAX_SILVER_SNIPERS = 900;
uint256 public MAX_GOLD_SNIPERS = 69;
uint256 public SILVER_SNIPER_PRICE = .223 ether;
uint256 public GOLD_SNIPER_PRICE = .696 ether;
uint256 private feePaid = 0;
// bytes
bytes32 merkleRoot;
string private _tokenSilverURI = 'ipfs://bafybeieirufnrbiuk7mcngbpijqfe6fuiyz2dcaeo7bxmoleuylbywnoti/metadata/silver_sniper';
string private _tokenGoldURI = 'ipfs://bafybeieirufnrbiuk7mcngbpijqfe6fuiyz2dcaeo7bxmoleuylbywnoti/metadata/gold_sniper';
//Mappings
mapping(uint256 => bool) private _tokenIsGold;
mapping(address => bool) private _tokenClaimed;
constructor(bytes32 _merkleRoot) ERC721("onlySnipers", "ONLYSNIPERS") {
}
function setMintingLive(bool isLive) external onlyOwner {
}
function setAllowListRequired(bool isRequired) external onlyOwner {
}
function addFeePaid(uint256 _feePaid) external {
}
/*
MINTING FUNCTIONS
*/
/**
* @dev Mint internal, this is to avoid code duplication.
*/
function mintInternal(bool isGold) internal returns(uint256 tokenId) {
}
/**
* @dev Public mint function
*/
function mint(bool isGold, bytes32[] calldata proof) payable external returns(uint256 tokenId) {
require(_isMintingLive, "Minting has not started");
require(
_totalSupply < MAX_SUPPLY,
"Tokens have all been minted"
);
require(<FILL_ME>)
// check whitelist
if(_isAllowListRequired){
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, merkleRoot, leaf), 'Proof is invalid');
}
if(isGold){
require(GOLD_SNIPER_SUPPLY < MAX_GOLD_SNIPERS, "All gold snipers have been minted");
require(msg.value == GOLD_SNIPER_PRICE, "Wrong amount of ether");
} else {
require(SILVER_SNIPER_SUPPLY < MAX_SILVER_SNIPERS, "All silver snipers have been minted");
require(msg.value == SILVER_SNIPER_PRICE, "Wrong amount of ether");
}
tokenId = mintInternal(isGold);
_tokenClaimed[msg.sender] = true;
return tokenId;
}
/**
* @dev Mint gift tokens for the contract owner
*/
function mintGifts(uint256 _times) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function getSupply()
public
view
returns (
uint256 maxSnipers,
uint256 maxGoldSnipers,
uint256 mintedSnipers,
uint256 mintedGoldSnipers
) {
}
function getClaimed(address _address) public view returns (bool hasClaimed) {
}
function addressIsWhitelisted(address _address, bytes32[] calldata proof) public view returns (bool isWhitelisted) {
}
/**
* @dev Withdraw ETH to owner
*/
function withdraw() public onlyOwner {
}
/**
* @dev Withdraw fee
*/
function withdrawFee() public onlyOwner {
}
}
| !_tokenClaimed[msg.sender],"This address already minted" | 319,348 | !_tokenClaimed[msg.sender] |
"Must mint fewer than the maximum number of gifted tokens" | // contracts/StakerNFT.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "./merkle/MerkleDistributor.sol";
contract SniperNFT is ERC721Enumerable, Ownable {
// bool
bool public _isMintingLive = false;
bool public _isAllowListRequired = true;
// addresses
address _owner;
address private feeReceiver;
// integers
uint256 public _totalSupply = 0;
uint256 public MAX_SUPPLY = 999;
uint256 public GIFT_SNIPER_SUPPLY = 0;
uint256 public SILVER_SNIPER_SUPPLY = 0;
uint256 public GOLD_SNIPER_SUPPLY = 0;
uint256 public MAX_GIFT_SNIPERS = 30;
uint256 public MAX_SILVER_SNIPERS = 900;
uint256 public MAX_GOLD_SNIPERS = 69;
uint256 public SILVER_SNIPER_PRICE = .223 ether;
uint256 public GOLD_SNIPER_PRICE = .696 ether;
uint256 private feePaid = 0;
// bytes
bytes32 merkleRoot;
string private _tokenSilverURI = 'ipfs://bafybeieirufnrbiuk7mcngbpijqfe6fuiyz2dcaeo7bxmoleuylbywnoti/metadata/silver_sniper';
string private _tokenGoldURI = 'ipfs://bafybeieirufnrbiuk7mcngbpijqfe6fuiyz2dcaeo7bxmoleuylbywnoti/metadata/gold_sniper';
//Mappings
mapping(uint256 => bool) private _tokenIsGold;
mapping(address => bool) private _tokenClaimed;
constructor(bytes32 _merkleRoot) ERC721("onlySnipers", "ONLYSNIPERS") {
}
function setMintingLive(bool isLive) external onlyOwner {
}
function setAllowListRequired(bool isRequired) external onlyOwner {
}
function addFeePaid(uint256 _feePaid) external {
}
/*
MINTING FUNCTIONS
*/
/**
* @dev Mint internal, this is to avoid code duplication.
*/
function mintInternal(bool isGold) internal returns(uint256 tokenId) {
}
/**
* @dev Public mint function
*/
function mint(bool isGold, bytes32[] calldata proof) payable external returns(uint256 tokenId) {
}
/**
* @dev Mint gift tokens for the contract owner
*/
function mintGifts(uint256 _times) external onlyOwner {
require(<FILL_ME>)
for(uint256 i=0; i<_times; i++) {
uint256 tokenId = 1 + MAX_GOLD_SNIPERS + GIFT_SNIPER_SUPPLY;
GIFT_SNIPER_SUPPLY += 1;
_totalSupply += 1;
_mint(msg.sender, tokenId);
}
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function getSupply()
public
view
returns (
uint256 maxSnipers,
uint256 maxGoldSnipers,
uint256 mintedSnipers,
uint256 mintedGoldSnipers
) {
}
function getClaimed(address _address) public view returns (bool hasClaimed) {
}
function addressIsWhitelisted(address _address, bytes32[] calldata proof) public view returns (bool isWhitelisted) {
}
/**
* @dev Withdraw ETH to owner
*/
function withdraw() public onlyOwner {
}
/**
* @dev Withdraw fee
*/
function withdrawFee() public onlyOwner {
}
}
| GIFT_SNIPER_SUPPLY+_times<=MAX_GIFT_SNIPERS,"Must mint fewer than the maximum number of gifted tokens" | 319,348 | GIFT_SNIPER_SUPPLY+_times<=MAX_GIFT_SNIPERS |
null | pragma solidity ^0.4.21;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
}
}
contract StandardToken is ERC20, BurnableToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifing the amount of tokens still avaible for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
}
}
contract ASGToken is StandardToken {
string constant public name = "ASGARD";
string constant public symbol = "ASG";
uint256 constant public decimals = 18;
address constant public marketingWallet = 0x341570A97E15DbA3D92dcc889Fff1bbd6709D20a;
uint256 public marketingPart = uint256(2100000000).mul(10 ** decimals); // 8.4% = 2 100 000 000 tokens
address constant public airdropWallet = 0xCB3D939804C97441C58D9AC6566A412768a7433B;
uint256 public airdropPart = uint256(1750000000).mul(10 ** decimals); // 7% = 1 750 000 000 tokens
address constant public bountyICOWallet = 0x5570EE8D93e730D8867A113ae45fB348BFc2e138;
uint256 public bountyICOPart = uint256(375000000).mul(10 ** decimals); // 1.5% = 375 000 000 tokens
address constant public bountyECOWallet = 0x89d90bA8135C77cDE1C3297076C5e1209806f048;
uint256 public bountyECOPart = uint256(375000000).mul(10 ** decimals); // 1.5% = 375 000 000 tokens
address constant public foundersWallet = 0xE03d060ac22fdC21fDF42eB72Eb4d8BA2444b1B0;
uint256 public foundersPart = uint256(2500000000).mul(10 ** decimals); // 10% = 2 500 000 000 tokens
address constant public cryptoExchangeWallet = 0x5E74DcA28cE21Bf066FC9eb7D10946316528d4d6;
uint256 public cryptoExchangePart = uint256(400000000).mul(10 ** decimals); // 1.6% = 400 000 000 tokens
address constant public ICOWallet = 0xCe2d50c646e83Ae17B7BFF3aE7611EDF0a75E03d;
uint256 public ICOPart = uint256(10000000000).mul(10 ** decimals); // 40% = 10 000 000 000 tokens
address constant public PreICOWallet = 0x83D921224c8B3E4c60E286B98Fd602CBa5d7B1AB;
uint256 public PreICOPart = uint256(7500000000).mul(10 ** decimals); // 30% = 7 500 000 000 tokens
uint256 public INITIAL_SUPPLY = uint256(25000000000).mul(10 ** decimals); // 100% = 25 000 000 000 tokens
constructor() public {
}
}
contract ASGPresale is Pausable {
using SafeMath for uint256;
ASGToken public tokenReward;
uint256 constant public decimals = 1000000000000000000; // 10 ** 18
uint256 public minimalPriceUSD = 5350; // 53.50 USD
uint256 public ETHUSD = 390; // 1 ETH = 390 USD
uint256 public tokenPricePerUSD = 1666; // 1 ASG = 0.1666 USD
uint256 public bonus = 0;
uint256 public tokensRaised;
constructor(address _tokenReward) public {
}
function () public payable {
}
function buy(address buyer) whenNotPaused public payable {
require(buyer != address(0));
require(<FILL_ME>)
uint256 tokens = msg.value.mul(ETHUSD).mul(bonus.add(100)).div(100).mul(10000).div(tokenPricePerUSD);
tokenReward.transfer(buyer, tokens);
tokensRaised = tokensRaised.add(tokens);
}
function tokenTransfer(address who, uint256 amount) onlyOwner public {
}
function updateMinimal(uint256 _minimalPriceUSD) onlyOwner public {
}
function updatePriceETHUSD(uint256 _ETHUSD) onlyOwner public {
}
function updatePriceASGUSD(uint256 _tokenPricePerUSD) onlyOwner public {
}
function updateBonus(uint256 _bonus) onlyOwner public {
}
function finishPresale() onlyOwner public {
}
}
| msg.value.mul(ETHUSD)>=minimalPriceUSD.mul(decimals).div(100) | 319,394 | msg.value.mul(ETHUSD)>=minimalPriceUSD.mul(decimals).div(100) |
null | pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) onlyOwner public {
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 6;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
/******************************************/
/* ZIB TOKEN STARTS HERE */
/******************************************/
contract ZIBToken is owned, TokenERC20 {
uint256 public sellPrice;
uint256 public buyPrice;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
/* Initializes contract with initial supply tokens to the creator of the contract */
function ZIBToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
}
/// @notice Buy tokens from contract by sending ether
function buy() payable public {
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
require(<FILL_ME>) // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
}
| address(this).balance>=amount*sellPrice | 319,473 | address(this).balance>=amount*sellPrice |
"You are not eligible for claim" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
import "./ERC20.sol";
contract PolkaDex is ERC20 {
address payable Owner;
uint256 immutable InitialBlockNumber ;
constructor() ERC20("Polkadex", "PDEX") {
}
function ClaimAfterVesting() public {
// The second tranch of vesting happens after 3 months (1 quarter = (3*30*24*60*60)/13.14 blocks) from TGE
require(block.number > InitialBlockNumber + 591781, "Time to claim vested tokens has not reached");
require(<FILL_ME>)
_mint(msg.sender, VestedTokens[msg.sender]);
VestedTokens[msg.sender] = 0;
}
modifier OnlyOwner {
}
function TransferOwnerShip(address payable NewAddress) public OnlyOwner {
}
function ShowOwner() public view returns (address) {
}
}
| VestedTokens[msg.sender]>0,"You are not eligible for claim" | 319,523 | VestedTokens[msg.sender]>0 |
null | pragma solidity ^0.4.20;
//standart library for uint
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function pow(uint256 a, uint256 b) internal pure returns (uint256){
}
}
//standart contract to identify owner
contract Ownable {
address public owner;
address public newOwner;
modifier onlyOwner() {
}
function Ownable() public {
}
function transferOwnership(address _newOwner) public onlyOwner {
}
function acceptOwnership() public {
}
}
contract DatareumToken is Ownable { //ERC - 20 token contract
using SafeMath for uint;
// Triggered when tokens are transferred.
event Transfer(address indexed _from, address indexed _to, uint256 _value);
// Triggered whenever approve(address _spender, uint256 _value) is called.
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
string public constant symbol = "DTN";
string public constant name = "Datareum";
uint8 public constant decimals = 18;
uint256 _totalSupply = 1000000000 ether;
// Owner of this contract
address public owner;
// Balances for each account
mapping(address => uint256) balances;
// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;
function totalSupply() public view returns (uint256) {
}
function balanceOf(address _address) public view returns (uint256 balance) {
}
bool public locked = true;
bool public canChangeLocked = true;
function changeLockTransfer (bool _request) public onlyOwner {
}
function finalUnlockTransfer () public {
}
//standart ERC-20 function
function transfer(address _to, uint256 _amount) public returns (bool success) {
}
//standart ERC-20 function
function transferFrom(address _from, address _to, uint256 _amount) public returns(bool success){
}
//standart ERC-20 function
function approve(address _spender, uint256 _amount)public returns (bool success) {
}
//standart ERC-20 function
function allowance(address _owner, address _spender)public constant returns (uint256 remaining) {
}
//Constructor
function DatareumToken() public {
}
address public crowdsaleContract;
function setCrowdsaleContract (address _address) public{
}
function endICO (uint _date) public {
}
uint public finishDate = 1893456000;
uint public crowdsaleBalance = 600000000 ether;
function sendCrowdsaleTokens (address _address, uint _value) public {
}
uint public advisorsBalance = 200000000 ether;
uint public foundersBalance = 100000000 ether;
uint public futureFundingBalance = 50000000 ether;
uint public bountyBalance = 50000000 ether;
function sendAdvisorsBalance (address[] _addresses, uint[] _values) external onlyOwner {
}
function sendFoundersBalance (address[] _addresses, uint[] _values) external onlyOwner {
}
function sendFutureFundingBalance (address[] _addresses, uint[] _values) external onlyOwner {
}
uint public constant PRE_ICO_FINISH = 1525737540;
mapping (address => bool) public bountyAddresses;
function addBountyAddresses (address[] _addresses) external onlyOwner {
}
function removeBountyAddresses (address[] _addresses) external onlyOwner {
}
function sendBountyBalance (address[] _addresses, uint[] _values) external {
require(now >= PRE_ICO_FINISH);
require(<FILL_ME>)
uint buffer = 0;
for(uint i = 0; i < _addresses.length; i++){
balances[_addresses[i]] = balances[_addresses[i]].add(_values[i]);
buffer = buffer.add(_values[i]);
emit Transfer(this,_addresses[i],_values[i]);
}
bountyBalance = bountyBalance.sub(buffer);
balances[this] = balances[this].sub(buffer);
}
}
| bountyAddresses[msg.sender] | 319,588 | bountyAddresses[msg.sender] |
null | contract ReferrerRole is Ownable {
using Roles for Roles.Role;
event ReferrerAdded(address indexed account);
event ReferrerRemoved(address indexed account);
Roles.Role private referrers;
constructor() public {
}
modifier onlyReferrer() {
require(<FILL_ME>)
_;
}
function isReferrer(address account) public view returns (bool) {
}
function addReferrer(address account) public onlyOwner() {
}
function removeReferrer(address account) public onlyOwner() {
}
}
| isReferrer(msg.sender) | 319,749 | isReferrer(msg.sender) |
null | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity ^0.8.0;
contract KoolKittensNFT is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
uint256 public cost = 20000000000000000; // 0.02 eth
uint256 public maxSupply = 3333;
uint256 public maxMintAmount = 20;
bool public paused = false;
mapping(address => bool) public whitelisted;
constructor() ERC721("Kool Kittens", "KoolKittens") { }
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(address _to, uint256 _mintAmount) public payable {
}
// free
function mintFREE(address _to, uint256 _claimAmount) public payable {
uint256 supply = totalSupply();
require(!paused);
require(_claimAmount > 0);
require(_claimAmount <= 1);
require(<FILL_ME>)
for (uint256 i = 1; i <= _claimAmount; i++) {
_safeMint(_to, supply + i);
}
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function whitelistUser(address _user) public onlyOwner {
}
function removeWhitelistUser(address _user) public onlyOwner {
}
function withdraw() onlyOwner public {
}
}
| supply+_claimAmount<=300 | 319,776 | supply+_claimAmount<=300 |
null | pragma solidity ^0.4.24;
// AddrSet is an address set based on http://solidity.readthedocs.io/en/develop/contracts.html#libraries
library AddrSet {
// We define a new struct datatype that will be used to
// hold its data in the calling contract.
struct Data { mapping(address => bool) flags; }
// Note that the first parameter is of type "storage
// reference" and thus only its storage address and not
// its contents is passed as part of the call. This is a
// special feature of library functions. It is idiomatic
// to call the first parameter `self`, if the function can
// be seen as a method of that object.
function insert(Data storage self, address value) internal returns (bool) {
}
function remove(Data storage self, address value) internal returns (bool) {
}
function contains(Data storage self, address value) internal view returns (bool) {
}
}
contract Owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
// Copyright 2017, 2018 Tensigma Ltd. All rights reserved.
// Use of this source code is governed by Microsoft Reference Source
// License (MS-RSL) that can be found in the LICENSE file.
// KYC implements "Know Your Customer" storage for identity approvals by KYC providers.
contract KYC is Owned {
// Status corresponding to the state of approvement:
// * Unknown when an address has not been processed yet;
// * Approved when an address has been approved by contract owner or 3rd party KYC provider;
// * Suspended means a temporary or permanent suspension of all operations, any KYC providers may
// set this status when account needs to be re-verified due to legal events or blocked because of fraud.
enum Status {
unknown,
approved,
suspended
}
// Events emitted by this contract
event ProviderAdded(address indexed addr);
event ProviderRemoved(address indexed addr);
event AddrApproved(address indexed addr, address indexed by);
event AddrSuspended(address indexed addr, address indexed by);
// Contract state
AddrSet.Data private kycProviders;
mapping(address => Status) public kycStatus;
// registerProvider adds a new 3rd-party provider that is authorized to perform KYC.
function registerProvider(address addr) public onlyOwner {
require(<FILL_ME>)
emit ProviderAdded(addr);
}
// removeProvider removes a 3rd-party provider that was authorized to perform KYC.
function removeProvider(address addr) public onlyOwner {
}
// isProvider returns true if the given address was authorized to perform KYC.
function isProvider(address addr) public view returns (bool) {
}
// getStatus returns the KYC status for a given address.
function getStatus(address addr) public view returns (Status) {
}
// approveAddr sets the address status to Approved, see Status for details.
// Can be invoked by owner or authorized KYC providers only.
function approveAddr(address addr) public onlyAuthorized {
}
// suspendAddr sets the address status to Suspended, see Status for details.
// Can be invoked by owner or authorized KYC providers only.
function suspendAddr(address addr) public onlyAuthorized {
}
// onlyAuthorized modifier restricts write access to contract owner and authorized KYC providers.
modifier onlyAuthorized() {
}
}
| AddrSet.insert(kycProviders,addr) | 319,786 | AddrSet.insert(kycProviders,addr) |
null | pragma solidity ^0.4.24;
// AddrSet is an address set based on http://solidity.readthedocs.io/en/develop/contracts.html#libraries
library AddrSet {
// We define a new struct datatype that will be used to
// hold its data in the calling contract.
struct Data { mapping(address => bool) flags; }
// Note that the first parameter is of type "storage
// reference" and thus only its storage address and not
// its contents is passed as part of the call. This is a
// special feature of library functions. It is idiomatic
// to call the first parameter `self`, if the function can
// be seen as a method of that object.
function insert(Data storage self, address value) internal returns (bool) {
}
function remove(Data storage self, address value) internal returns (bool) {
}
function contains(Data storage self, address value) internal view returns (bool) {
}
}
contract Owned {
address public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
// Copyright 2017, 2018 Tensigma Ltd. All rights reserved.
// Use of this source code is governed by Microsoft Reference Source
// License (MS-RSL) that can be found in the LICENSE file.
// KYC implements "Know Your Customer" storage for identity approvals by KYC providers.
contract KYC is Owned {
// Status corresponding to the state of approvement:
// * Unknown when an address has not been processed yet;
// * Approved when an address has been approved by contract owner or 3rd party KYC provider;
// * Suspended means a temporary or permanent suspension of all operations, any KYC providers may
// set this status when account needs to be re-verified due to legal events or blocked because of fraud.
enum Status {
unknown,
approved,
suspended
}
// Events emitted by this contract
event ProviderAdded(address indexed addr);
event ProviderRemoved(address indexed addr);
event AddrApproved(address indexed addr, address indexed by);
event AddrSuspended(address indexed addr, address indexed by);
// Contract state
AddrSet.Data private kycProviders;
mapping(address => Status) public kycStatus;
// registerProvider adds a new 3rd-party provider that is authorized to perform KYC.
function registerProvider(address addr) public onlyOwner {
}
// removeProvider removes a 3rd-party provider that was authorized to perform KYC.
function removeProvider(address addr) public onlyOwner {
require(<FILL_ME>)
emit ProviderRemoved(addr);
}
// isProvider returns true if the given address was authorized to perform KYC.
function isProvider(address addr) public view returns (bool) {
}
// getStatus returns the KYC status for a given address.
function getStatus(address addr) public view returns (Status) {
}
// approveAddr sets the address status to Approved, see Status for details.
// Can be invoked by owner or authorized KYC providers only.
function approveAddr(address addr) public onlyAuthorized {
}
// suspendAddr sets the address status to Suspended, see Status for details.
// Can be invoked by owner or authorized KYC providers only.
function suspendAddr(address addr) public onlyAuthorized {
}
// onlyAuthorized modifier restricts write access to contract owner and authorized KYC providers.
modifier onlyAuthorized() {
}
}
| AddrSet.remove(kycProviders,addr) | 319,786 | AddrSet.remove(kycProviders,addr) |
"Reached max supply for this batch" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./MerkleProof.sol";
contract TheVoxelUniverse is ERC721A, Ownable {
string public baseURI;
uint256 public MINT_PRICE = 0.05 ether;
bool public presaleActive = false;
bool public publicSaleActive = false;
uint32 public batchCounter;
uint32 public BATCH_SIZE = 500;
mapping(address => mapping(uint => uint)) presaleMintsTracker;
mapping(address => mapping(uint => uint)) publicSaleMintsTracker;
mapping(uint => uint) public maxPresaleMintsPerWalletForBatch;
mapping(uint => uint) public maxPublicMintsPerWalletForBatch;
mapping(uint => uint) public batchTotalMintsCounter;
bytes32 public merkleRoot;
constructor() ERC721A("The Voxel Universe", "VOXU", 10) {
}
function mint(uint numberOfMints) public payable {
address msgSender = msg.sender;
require(tx.origin == msgSender, "Only EOA");
require(publicSaleActive, "Public sale is not active");
require(<FILL_ME>)
require((publicSaleMintsTracker[msgSender][batchCounter] + numberOfMints) <= maxPublicMintsPerWalletForBatch[batchCounter], "You can't mint more for this batch");
require((MINT_PRICE * numberOfMints) == msg.value, "Invalid ETH value sent");
batchTotalMintsCounter[batchCounter] += numberOfMints;
publicSaleMintsTracker[msgSender][batchCounter] += numberOfMints;
_safeMint(msgSender, numberOfMints);
}
function presaleMint(uint numberOfMints, bytes32[] calldata _merkleProof) public payable {
}
function gift(address[] calldata destinations) public onlyOwner {
}
function setSaleStatus(bool _presale, bool _public) public onlyOwner {
}
function setMaxLimits(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet) public onlyOwner {
}
function goToNextBatch(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet, bytes32 _merkleRoot) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setBatchSize(uint32 new_batch_size) public onlyOwner {
}
function setMintPrice(uint new_price) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| (batchTotalMintsCounter[batchCounter]+numberOfMints)<=BATCH_SIZE,"Reached max supply for this batch" | 319,953 | (batchTotalMintsCounter[batchCounter]+numberOfMints)<=BATCH_SIZE |
"You can't mint more for this batch" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./MerkleProof.sol";
contract TheVoxelUniverse is ERC721A, Ownable {
string public baseURI;
uint256 public MINT_PRICE = 0.05 ether;
bool public presaleActive = false;
bool public publicSaleActive = false;
uint32 public batchCounter;
uint32 public BATCH_SIZE = 500;
mapping(address => mapping(uint => uint)) presaleMintsTracker;
mapping(address => mapping(uint => uint)) publicSaleMintsTracker;
mapping(uint => uint) public maxPresaleMintsPerWalletForBatch;
mapping(uint => uint) public maxPublicMintsPerWalletForBatch;
mapping(uint => uint) public batchTotalMintsCounter;
bytes32 public merkleRoot;
constructor() ERC721A("The Voxel Universe", "VOXU", 10) {
}
function mint(uint numberOfMints) public payable {
address msgSender = msg.sender;
require(tx.origin == msgSender, "Only EOA");
require(publicSaleActive, "Public sale is not active");
require((batchTotalMintsCounter[batchCounter] + numberOfMints) <= BATCH_SIZE, "Reached max supply for this batch");
require(<FILL_ME>)
require((MINT_PRICE * numberOfMints) == msg.value, "Invalid ETH value sent");
batchTotalMintsCounter[batchCounter] += numberOfMints;
publicSaleMintsTracker[msgSender][batchCounter] += numberOfMints;
_safeMint(msgSender, numberOfMints);
}
function presaleMint(uint numberOfMints, bytes32[] calldata _merkleProof) public payable {
}
function gift(address[] calldata destinations) public onlyOwner {
}
function setSaleStatus(bool _presale, bool _public) public onlyOwner {
}
function setMaxLimits(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet) public onlyOwner {
}
function goToNextBatch(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet, bytes32 _merkleRoot) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setBatchSize(uint32 new_batch_size) public onlyOwner {
}
function setMintPrice(uint new_price) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| (publicSaleMintsTracker[msgSender][batchCounter]+numberOfMints)<=maxPublicMintsPerWalletForBatch[batchCounter],"You can't mint more for this batch" | 319,953 | (publicSaleMintsTracker[msgSender][batchCounter]+numberOfMints)<=maxPublicMintsPerWalletForBatch[batchCounter] |
"Invalid ETH value sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./MerkleProof.sol";
contract TheVoxelUniverse is ERC721A, Ownable {
string public baseURI;
uint256 public MINT_PRICE = 0.05 ether;
bool public presaleActive = false;
bool public publicSaleActive = false;
uint32 public batchCounter;
uint32 public BATCH_SIZE = 500;
mapping(address => mapping(uint => uint)) presaleMintsTracker;
mapping(address => mapping(uint => uint)) publicSaleMintsTracker;
mapping(uint => uint) public maxPresaleMintsPerWalletForBatch;
mapping(uint => uint) public maxPublicMintsPerWalletForBatch;
mapping(uint => uint) public batchTotalMintsCounter;
bytes32 public merkleRoot;
constructor() ERC721A("The Voxel Universe", "VOXU", 10) {
}
function mint(uint numberOfMints) public payable {
address msgSender = msg.sender;
require(tx.origin == msgSender, "Only EOA");
require(publicSaleActive, "Public sale is not active");
require((batchTotalMintsCounter[batchCounter] + numberOfMints) <= BATCH_SIZE, "Reached max supply for this batch");
require((publicSaleMintsTracker[msgSender][batchCounter] + numberOfMints) <= maxPublicMintsPerWalletForBatch[batchCounter], "You can't mint more for this batch");
require(<FILL_ME>)
batchTotalMintsCounter[batchCounter] += numberOfMints;
publicSaleMintsTracker[msgSender][batchCounter] += numberOfMints;
_safeMint(msgSender, numberOfMints);
}
function presaleMint(uint numberOfMints, bytes32[] calldata _merkleProof) public payable {
}
function gift(address[] calldata destinations) public onlyOwner {
}
function setSaleStatus(bool _presale, bool _public) public onlyOwner {
}
function setMaxLimits(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet) public onlyOwner {
}
function goToNextBatch(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet, bytes32 _merkleRoot) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setBatchSize(uint32 new_batch_size) public onlyOwner {
}
function setMintPrice(uint new_price) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| (MINT_PRICE*numberOfMints)==msg.value,"Invalid ETH value sent" | 319,953 | (MINT_PRICE*numberOfMints)==msg.value |
"You can't mint more for this batch" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./MerkleProof.sol";
contract TheVoxelUniverse is ERC721A, Ownable {
string public baseURI;
uint256 public MINT_PRICE = 0.05 ether;
bool public presaleActive = false;
bool public publicSaleActive = false;
uint32 public batchCounter;
uint32 public BATCH_SIZE = 500;
mapping(address => mapping(uint => uint)) presaleMintsTracker;
mapping(address => mapping(uint => uint)) publicSaleMintsTracker;
mapping(uint => uint) public maxPresaleMintsPerWalletForBatch;
mapping(uint => uint) public maxPublicMintsPerWalletForBatch;
mapping(uint => uint) public batchTotalMintsCounter;
bytes32 public merkleRoot;
constructor() ERC721A("The Voxel Universe", "VOXU", 10) {
}
function mint(uint numberOfMints) public payable {
}
function presaleMint(uint numberOfMints, bytes32[] calldata _merkleProof) public payable {
address msgSender = msg.sender;
require(tx.origin == msgSender, "Only EOA");
require(presaleActive, "Presale is not active");
require((batchTotalMintsCounter[batchCounter] + numberOfMints) <= BATCH_SIZE, "Reached max supply for this batch");
require(<FILL_ME>)
require((MINT_PRICE * numberOfMints) == msg.value, "Invalid ETH value sent");
bytes32 leaf = keccak256(abi.encodePacked(msgSender));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Invalid proof");
batchTotalMintsCounter[batchCounter] += numberOfMints;
presaleMintsTracker[msgSender][batchCounter] += numberOfMints;
_safeMint(msgSender, numberOfMints);
}
function gift(address[] calldata destinations) public onlyOwner {
}
function setSaleStatus(bool _presale, bool _public) public onlyOwner {
}
function setMaxLimits(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet) public onlyOwner {
}
function goToNextBatch(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet, bytes32 _merkleRoot) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setBatchSize(uint32 new_batch_size) public onlyOwner {
}
function setMintPrice(uint new_price) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| (presaleMintsTracker[msgSender][batchCounter]+numberOfMints)<=maxPresaleMintsPerWalletForBatch[batchCounter],"You can't mint more for this batch" | 319,953 | (presaleMintsTracker[msgSender][batchCounter]+numberOfMints)<=maxPresaleMintsPerWalletForBatch[batchCounter] |
"Reached max supply for this batch" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./MerkleProof.sol";
contract TheVoxelUniverse is ERC721A, Ownable {
string public baseURI;
uint256 public MINT_PRICE = 0.05 ether;
bool public presaleActive = false;
bool public publicSaleActive = false;
uint32 public batchCounter;
uint32 public BATCH_SIZE = 500;
mapping(address => mapping(uint => uint)) presaleMintsTracker;
mapping(address => mapping(uint => uint)) publicSaleMintsTracker;
mapping(uint => uint) public maxPresaleMintsPerWalletForBatch;
mapping(uint => uint) public maxPublicMintsPerWalletForBatch;
mapping(uint => uint) public batchTotalMintsCounter;
bytes32 public merkleRoot;
constructor() ERC721A("The Voxel Universe", "VOXU", 10) {
}
function mint(uint numberOfMints) public payable {
}
function presaleMint(uint numberOfMints, bytes32[] calldata _merkleProof) public payable {
}
function gift(address[] calldata destinations) public onlyOwner {
require(<FILL_ME>)
batchTotalMintsCounter[batchCounter] += destinations.length;
for (uint i = 0; i < destinations.length; i++) {
_safeMint(destinations[i], 1);
}
}
function setSaleStatus(bool _presale, bool _public) public onlyOwner {
}
function setMaxLimits(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet) public onlyOwner {
}
function goToNextBatch(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet, bytes32 _merkleRoot) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setBatchSize(uint32 new_batch_size) public onlyOwner {
}
function setMintPrice(uint new_price) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| (batchTotalMintsCounter[batchCounter]+destinations.length)<=BATCH_SIZE,"Reached max supply for this batch" | 319,953 | (batchTotalMintsCounter[batchCounter]+destinations.length)<=BATCH_SIZE |
"Can't both be active" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./MerkleProof.sol";
contract TheVoxelUniverse is ERC721A, Ownable {
string public baseURI;
uint256 public MINT_PRICE = 0.05 ether;
bool public presaleActive = false;
bool public publicSaleActive = false;
uint32 public batchCounter;
uint32 public BATCH_SIZE = 500;
mapping(address => mapping(uint => uint)) presaleMintsTracker;
mapping(address => mapping(uint => uint)) publicSaleMintsTracker;
mapping(uint => uint) public maxPresaleMintsPerWalletForBatch;
mapping(uint => uint) public maxPublicMintsPerWalletForBatch;
mapping(uint => uint) public batchTotalMintsCounter;
bytes32 public merkleRoot;
constructor() ERC721A("The Voxel Universe", "VOXU", 10) {
}
function mint(uint numberOfMints) public payable {
}
function presaleMint(uint numberOfMints, bytes32[] calldata _merkleProof) public payable {
}
function gift(address[] calldata destinations) public onlyOwner {
}
function setSaleStatus(bool _presale, bool _public) public onlyOwner {
require(<FILL_ME>)
presaleActive = _presale;
publicSaleActive = _public;
}
function setMaxLimits(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet) public onlyOwner {
}
function goToNextBatch(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet, bytes32 _merkleRoot) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setBatchSize(uint32 new_batch_size) public onlyOwner {
}
function setMintPrice(uint new_price) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| !(_presale==true&&_public==true),"Can't both be active" | 319,953 | !(_presale==true&&_public==true) |
"Current batch did not mint out yet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./MerkleProof.sol";
contract TheVoxelUniverse is ERC721A, Ownable {
string public baseURI;
uint256 public MINT_PRICE = 0.05 ether;
bool public presaleActive = false;
bool public publicSaleActive = false;
uint32 public batchCounter;
uint32 public BATCH_SIZE = 500;
mapping(address => mapping(uint => uint)) presaleMintsTracker;
mapping(address => mapping(uint => uint)) publicSaleMintsTracker;
mapping(uint => uint) public maxPresaleMintsPerWalletForBatch;
mapping(uint => uint) public maxPublicMintsPerWalletForBatch;
mapping(uint => uint) public batchTotalMintsCounter;
bytes32 public merkleRoot;
constructor() ERC721A("The Voxel Universe", "VOXU", 10) {
}
function mint(uint numberOfMints) public payable {
}
function presaleMint(uint numberOfMints, bytes32[] calldata _merkleProof) public payable {
}
function gift(address[] calldata destinations) public onlyOwner {
}
function setSaleStatus(bool _presale, bool _public) public onlyOwner {
}
function setMaxLimits(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet) public onlyOwner {
}
function goToNextBatch(uint _maxPresaleMintsPerWallet, uint _maxPublicSaleMintsPerWallet, bytes32 _merkleRoot) public onlyOwner {
require(<FILL_ME>)
require(_maxPresaleMintsPerWallet <= 10 && _maxPublicSaleMintsPerWallet <= 10, "Max cannot be more than 10");
batchCounter++;
merkleRoot = _merkleRoot;
batchTotalMintsCounter[batchCounter] = 0;
maxPresaleMintsPerWalletForBatch[batchCounter] = _maxPresaleMintsPerWallet;
maxPublicMintsPerWalletForBatch[batchCounter] = _maxPublicSaleMintsPerWallet;
presaleActive = false;
publicSaleActive = false;
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setBatchSize(uint32 new_batch_size) public onlyOwner {
}
function setMintPrice(uint new_price) public onlyOwner {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| totalSupply()%BATCH_SIZE==0,"Current batch did not mint out yet" | 319,953 | totalSupply()%BATCH_SIZE==0 |
'T' | /// @title Math library for computing sqrt prices from ticks and vice versa
/// @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports
/// prices between 2**-128 and 2**128
library TickMath {
/// @dev The minimum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**-128
int24 internal constant MIN_TICK = -887272;
/// @dev The maximum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**128
int24 internal constant MAX_TICK = -MIN_TICK;
/// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
/// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
/// @return sqrtPriceX96 A Fixed point Q64.96 number representing the sqrt of the ratio of the two assets (token1/token0)
/// at the given tick
function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
require(<FILL_ME>)
uint256 ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
if (tick > 0) ratio = type(uint256).max / ratio;
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// we then downcast because we know the result always fits within 160 bits due to our tick input constraint
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
}
/// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
/// @dev Throws in case sqrtPriceX96 < MIN_SQRT_RATIO, as MIN_SQRT_RATIO is the lowest value getRatioAtTick may
/// ever return.
/// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
/// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
function getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
}
}
| int256(absTick)<=int256(MAX_TICK),'T' | 320,008 | int256(absTick)<=int256(MAX_TICK) |
"Airdrop > Max" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SaltyPirateCrew is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 3000;
uint256 public constant GIFT_BUFFER = 67;
uint256 public constant PRICE = 0.06 ether;
uint256 public constant SNAPSHOT = 232;
Counters.Counter private _tokenIdCounter;
Counters.Counter public giftsSent;
Counters.Counter public _snapshotCounter;
address private signer;
uint256 public maxPresaleMint;
string public baseURI;
enum ContractState { PAUSED, PRESALE1, PRESALE2, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
mapping(address => uint256) public whitelist;
constructor(
address _signer,
uint256 _maxPresaleMint,
string memory _URI) ERC721("SaltyPirateCrew", "SPC") {
}
// Verifies that the sender is whitelisted
function _verify(address sender, bytes memory signature) internal view returns (bool) {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function giftsRemaining() public view returns (uint256) {
}
// Returns the total supply minted
function totalSupply() public view returns (uint256) {
}
// Sets a new contract state: PAUSED, PRESALE1, PRESALE2, PUBLIC.
function setContractState(ContractState _newState) external onlyOwner {
}
// Sets a new maximum for presale minting
function setMaxPresaleMint(uint256 _newMaxPresaleMint) external onlyOwner {
}
function airdrop(uint256 airdropAmount, address to) public onlyOwner {
require(airdropAmount > 0, "Airdrop != 0");
require(<FILL_ME>)
for(uint i = 0; i < airdropAmount; i++) {
uint256 tokenId = _snapshotCounter.current();
_snapshotCounter.increment();
_safeMint(to, tokenId);
}
}
// Gift function that will send the address passed the gift amount
function gift(uint256 giftAmount, address to) public onlyOwner {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer or whitelisted allocation.
function firstPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer.
function secondPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10. Does not allow to mint beyond the gift buffer.
function mint(uint256 mintAmount) public payable nonReentrant {
}
// Withdraw funds
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| _snapshotCounter.current()+airdropAmount<=SNAPSHOT,"Airdrop > Max" | 320,024 | _snapshotCounter.current()+airdropAmount<=SNAPSHOT |
"Gifting exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SaltyPirateCrew is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 3000;
uint256 public constant GIFT_BUFFER = 67;
uint256 public constant PRICE = 0.06 ether;
uint256 public constant SNAPSHOT = 232;
Counters.Counter private _tokenIdCounter;
Counters.Counter public giftsSent;
Counters.Counter public _snapshotCounter;
address private signer;
uint256 public maxPresaleMint;
string public baseURI;
enum ContractState { PAUSED, PRESALE1, PRESALE2, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
mapping(address => uint256) public whitelist;
constructor(
address _signer,
uint256 _maxPresaleMint,
string memory _URI) ERC721("SaltyPirateCrew", "SPC") {
}
// Verifies that the sender is whitelisted
function _verify(address sender, bytes memory signature) internal view returns (bool) {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function giftsRemaining() public view returns (uint256) {
}
// Returns the total supply minted
function totalSupply() public view returns (uint256) {
}
// Sets a new contract state: PAUSED, PRESALE1, PRESALE2, PUBLIC.
function setContractState(ContractState _newState) external onlyOwner {
}
// Sets a new maximum for presale minting
function setMaxPresaleMint(uint256 _newMaxPresaleMint) external onlyOwner {
}
function airdrop(uint256 airdropAmount, address to) public onlyOwner {
}
// Gift function that will send the address passed the gift amount
function gift(uint256 giftAmount, address to) public onlyOwner {
require(giftAmount > 0, "Gift != 0");
require(<FILL_ME>)
require(giftAmount + _tokenIdCounter.current() <= MAX_SUPPLY - SNAPSHOT , "Gift > Max");
for(uint i = 0; i < giftAmount; i++) {
uint256 tokenId = _tokenIdCounter.current() + SNAPSHOT;
_tokenIdCounter.increment();
giftsSent.increment();
_safeMint(to, tokenId);
}
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer or whitelisted allocation.
function firstPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer.
function secondPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10. Does not allow to mint beyond the gift buffer.
function mint(uint256 mintAmount) public payable nonReentrant {
}
// Withdraw funds
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| giftsSent.current()+giftAmount<=GIFT_BUFFER,"Gifting exceeded" | 320,024 | giftsSent.current()+giftAmount<=GIFT_BUFFER |
"Gift > Max" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SaltyPirateCrew is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 3000;
uint256 public constant GIFT_BUFFER = 67;
uint256 public constant PRICE = 0.06 ether;
uint256 public constant SNAPSHOT = 232;
Counters.Counter private _tokenIdCounter;
Counters.Counter public giftsSent;
Counters.Counter public _snapshotCounter;
address private signer;
uint256 public maxPresaleMint;
string public baseURI;
enum ContractState { PAUSED, PRESALE1, PRESALE2, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
mapping(address => uint256) public whitelist;
constructor(
address _signer,
uint256 _maxPresaleMint,
string memory _URI) ERC721("SaltyPirateCrew", "SPC") {
}
// Verifies that the sender is whitelisted
function _verify(address sender, bytes memory signature) internal view returns (bool) {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function giftsRemaining() public view returns (uint256) {
}
// Returns the total supply minted
function totalSupply() public view returns (uint256) {
}
// Sets a new contract state: PAUSED, PRESALE1, PRESALE2, PUBLIC.
function setContractState(ContractState _newState) external onlyOwner {
}
// Sets a new maximum for presale minting
function setMaxPresaleMint(uint256 _newMaxPresaleMint) external onlyOwner {
}
function airdrop(uint256 airdropAmount, address to) public onlyOwner {
}
// Gift function that will send the address passed the gift amount
function gift(uint256 giftAmount, address to) public onlyOwner {
require(giftAmount > 0, "Gift != 0");
require(giftsSent.current() + giftAmount <= GIFT_BUFFER, "Gifting exceeded");
require(<FILL_ME>)
for(uint i = 0; i < giftAmount; i++) {
uint256 tokenId = _tokenIdCounter.current() + SNAPSHOT;
_tokenIdCounter.increment();
giftsSent.increment();
_safeMint(to, tokenId);
}
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer or whitelisted allocation.
function firstPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer.
function secondPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10. Does not allow to mint beyond the gift buffer.
function mint(uint256 mintAmount) public payable nonReentrant {
}
// Withdraw funds
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| giftAmount+_tokenIdCounter.current()<=MAX_SUPPLY-SNAPSHOT,"Gift > Max" | 320,024 | giftAmount+_tokenIdCounter.current()<=MAX_SUPPLY-SNAPSHOT |
"You are not on the whitelist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SaltyPirateCrew is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 3000;
uint256 public constant GIFT_BUFFER = 67;
uint256 public constant PRICE = 0.06 ether;
uint256 public constant SNAPSHOT = 232;
Counters.Counter private _tokenIdCounter;
Counters.Counter public giftsSent;
Counters.Counter public _snapshotCounter;
address private signer;
uint256 public maxPresaleMint;
string public baseURI;
enum ContractState { PAUSED, PRESALE1, PRESALE2, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
mapping(address => uint256) public whitelist;
constructor(
address _signer,
uint256 _maxPresaleMint,
string memory _URI) ERC721("SaltyPirateCrew", "SPC") {
}
// Verifies that the sender is whitelisted
function _verify(address sender, bytes memory signature) internal view returns (bool) {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function giftsRemaining() public view returns (uint256) {
}
// Returns the total supply minted
function totalSupply() public view returns (uint256) {
}
// Sets a new contract state: PAUSED, PRESALE1, PRESALE2, PUBLIC.
function setContractState(ContractState _newState) external onlyOwner {
}
// Sets a new maximum for presale minting
function setMaxPresaleMint(uint256 _newMaxPresaleMint) external onlyOwner {
}
function airdrop(uint256 airdropAmount, address to) public onlyOwner {
}
// Gift function that will send the address passed the gift amount
function gift(uint256 giftAmount, address to) public onlyOwner {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer or whitelisted allocation.
function firstPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
require(currentState == ContractState.PRESALE1, "First presale not in session");
require(<FILL_ME>)
require(mintAmount > 0, "Can't mint 0");
require(mintAmount + _tokenIdCounter.current() <= MAX_SUPPLY - giftsRemaining() - SNAPSHOT, "Minting more than max supply");
require(mintAmount < 11, "Max mint is 10");
require(msg.value == PRICE * mintAmount, "Wrong price");
require(whitelist[msg.sender] + mintAmount <= maxPresaleMint, "Minting more than your whitelist allocation");
for(uint i = 0; i < mintAmount; i++) {
uint256 tokenId = _tokenIdCounter.current() + SNAPSHOT;
_tokenIdCounter.increment();
whitelist[msg.sender]++;
_safeMint(msg.sender, tokenId);
}
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer.
function secondPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10. Does not allow to mint beyond the gift buffer.
function mint(uint256 mintAmount) public payable nonReentrant {
}
// Withdraw funds
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| _verify(msg.sender,_signature),"You are not on the whitelist" | 320,024 | _verify(msg.sender,_signature) |
"Minting more than max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SaltyPirateCrew is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 3000;
uint256 public constant GIFT_BUFFER = 67;
uint256 public constant PRICE = 0.06 ether;
uint256 public constant SNAPSHOT = 232;
Counters.Counter private _tokenIdCounter;
Counters.Counter public giftsSent;
Counters.Counter public _snapshotCounter;
address private signer;
uint256 public maxPresaleMint;
string public baseURI;
enum ContractState { PAUSED, PRESALE1, PRESALE2, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
mapping(address => uint256) public whitelist;
constructor(
address _signer,
uint256 _maxPresaleMint,
string memory _URI) ERC721("SaltyPirateCrew", "SPC") {
}
// Verifies that the sender is whitelisted
function _verify(address sender, bytes memory signature) internal view returns (bool) {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function giftsRemaining() public view returns (uint256) {
}
// Returns the total supply minted
function totalSupply() public view returns (uint256) {
}
// Sets a new contract state: PAUSED, PRESALE1, PRESALE2, PUBLIC.
function setContractState(ContractState _newState) external onlyOwner {
}
// Sets a new maximum for presale minting
function setMaxPresaleMint(uint256 _newMaxPresaleMint) external onlyOwner {
}
function airdrop(uint256 airdropAmount, address to) public onlyOwner {
}
// Gift function that will send the address passed the gift amount
function gift(uint256 giftAmount, address to) public onlyOwner {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer or whitelisted allocation.
function firstPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
require(currentState == ContractState.PRESALE1, "First presale not in session");
require(_verify(msg.sender, _signature), "You are not on the whitelist");
require(mintAmount > 0, "Can't mint 0");
require(<FILL_ME>)
require(mintAmount < 11, "Max mint is 10");
require(msg.value == PRICE * mintAmount, "Wrong price");
require(whitelist[msg.sender] + mintAmount <= maxPresaleMint, "Minting more than your whitelist allocation");
for(uint i = 0; i < mintAmount; i++) {
uint256 tokenId = _tokenIdCounter.current() + SNAPSHOT;
_tokenIdCounter.increment();
whitelist[msg.sender]++;
_safeMint(msg.sender, tokenId);
}
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer.
function secondPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10. Does not allow to mint beyond the gift buffer.
function mint(uint256 mintAmount) public payable nonReentrant {
}
// Withdraw funds
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| mintAmount+_tokenIdCounter.current()<=MAX_SUPPLY-giftsRemaining()-SNAPSHOT,"Minting more than max supply" | 320,024 | mintAmount+_tokenIdCounter.current()<=MAX_SUPPLY-giftsRemaining()-SNAPSHOT |
"Minting more than your whitelist allocation" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SaltyPirateCrew is ERC721, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using ECDSA for bytes32;
uint256 public constant MAX_SUPPLY = 3000;
uint256 public constant GIFT_BUFFER = 67;
uint256 public constant PRICE = 0.06 ether;
uint256 public constant SNAPSHOT = 232;
Counters.Counter private _tokenIdCounter;
Counters.Counter public giftsSent;
Counters.Counter public _snapshotCounter;
address private signer;
uint256 public maxPresaleMint;
string public baseURI;
enum ContractState { PAUSED, PRESALE1, PRESALE2, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
mapping(address => uint256) public whitelist;
constructor(
address _signer,
uint256 _maxPresaleMint,
string memory _URI) ERC721("SaltyPirateCrew", "SPC") {
}
// Verifies that the sender is whitelisted
function _verify(address sender, bytes memory signature) internal view returns (bool) {
}
function setBaseURI(string memory _URI) public onlyOwner {
}
function giftsRemaining() public view returns (uint256) {
}
// Returns the total supply minted
function totalSupply() public view returns (uint256) {
}
// Sets a new contract state: PAUSED, PRESALE1, PRESALE2, PUBLIC.
function setContractState(ContractState _newState) external onlyOwner {
}
// Sets a new maximum for presale minting
function setMaxPresaleMint(uint256 _newMaxPresaleMint) external onlyOwner {
}
function airdrop(uint256 airdropAmount, address to) public onlyOwner {
}
// Gift function that will send the address passed the gift amount
function gift(uint256 giftAmount, address to) public onlyOwner {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer or whitelisted allocation.
function firstPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
require(currentState == ContractState.PRESALE1, "First presale not in session");
require(_verify(msg.sender, _signature), "You are not on the whitelist");
require(mintAmount > 0, "Can't mint 0");
require(mintAmount + _tokenIdCounter.current() <= MAX_SUPPLY - giftsRemaining() - SNAPSHOT, "Minting more than max supply");
require(mintAmount < 11, "Max mint is 10");
require(msg.value == PRICE * mintAmount, "Wrong price");
require(<FILL_ME>)
for(uint i = 0; i < mintAmount; i++) {
uint256 tokenId = _tokenIdCounter.current() + SNAPSHOT;
_tokenIdCounter.increment();
whitelist[msg.sender]++;
_safeMint(msg.sender, tokenId);
}
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10 and that user is whitelisted. Does not allow to mint beyond the gift buffer.
function secondPresale(uint256 mintAmount, bytes memory _signature) public payable nonReentrant {
}
// Mint function uses OpenZeppelin's mint functions to ensure safety.
// Requires ensure that minting is 1-10. Does not allow to mint beyond the gift buffer.
function mint(uint256 mintAmount) public payable nonReentrant {
}
// Withdraw funds
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| whitelist[msg.sender]+mintAmount<=maxPresaleMint,"Minting more than your whitelist allocation" | 320,024 | whitelist[msg.sender]+mintAmount<=maxPresaleMint |
"Already activated!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @author: manifold.xyz
import "@manifoldxyz/libraries-solidity/contracts/access/AdminControl.sol";
import "./core/IERC721CreatorCore.sol";
import "./extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
/**
* DAT.XYZ - Drop 01
* A Nifty Gateway drop
*/
contract DATDOTXYZ01 is AdminControl, ICreatorExtensionTokenURI, ReentrancyGuard {
using Strings for uint256;
bool private _active;
uint256 private _total;
uint256 private _totalMinted;
address private _creator;
address private _nifty_omnibus_wallet;
string[] private _uriParts;
mapping(uint256 => uint256) private _tokenEdition;
string constant private _EDITION_TAG = '<EDITION>';
string constant private _TOTAL_TAG = '<TOTAL>';
constructor(address creator) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function activate(uint256 total, address nifty_omnibus_wallet) external adminRequired {
require(<FILL_ME>)
_active = true;
_total = total;
_totalMinted = 0;
_nifty_omnibus_wallet = nifty_omnibus_wallet;
}
function _mintCount(uint256 niftyType) external view returns (uint256) {
}
function mintNifty(uint256 niftyType, uint256 count) external adminRequired nonReentrant {
}
function tokenURI(address creator, uint256 tokenId) external view override returns (string memory) {
}
function _generateURI(uint256 tokenId) private view returns(string memory) {
}
function _checkTag(string storage a, string memory b) private pure returns (bool) {
}
/**
* @dev update the URI data
*/
function updateURIParts(string[] memory uriParts) public adminRequired {
}
}
| !_active,"Already activated!" | 320,026 | !_active |
"Too many requested." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @author: manifold.xyz
import "@manifoldxyz/libraries-solidity/contracts/access/AdminControl.sol";
import "./core/IERC721CreatorCore.sol";
import "./extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
/**
* DAT.XYZ - Drop 01
* A Nifty Gateway drop
*/
contract DATDOTXYZ01 is AdminControl, ICreatorExtensionTokenURI, ReentrancyGuard {
using Strings for uint256;
bool private _active;
uint256 private _total;
uint256 private _totalMinted;
address private _creator;
address private _nifty_omnibus_wallet;
string[] private _uriParts;
mapping(uint256 => uint256) private _tokenEdition;
string constant private _EDITION_TAG = '<EDITION>';
string constant private _TOTAL_TAG = '<TOTAL>';
constructor(address creator) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function activate(uint256 total, address nifty_omnibus_wallet) external adminRequired {
}
function _mintCount(uint256 niftyType) external view returns (uint256) {
}
function mintNifty(uint256 niftyType, uint256 count) external adminRequired nonReentrant {
require(_active, "Not activated.");
require(<FILL_ME>)
require(niftyType == 1, "Only supports niftyType is 1");
for (uint256 i = 0; i < count; i++) {
_tokenEdition[IERC721CreatorCore(_creator).mintExtension(_nifty_omnibus_wallet)] = _totalMinted + i + 1;
}
_totalMinted += count;
}
function tokenURI(address creator, uint256 tokenId) external view override returns (string memory) {
}
function _generateURI(uint256 tokenId) private view returns(string memory) {
}
function _checkTag(string storage a, string memory b) private pure returns (bool) {
}
/**
* @dev update the URI data
*/
function updateURIParts(string[] memory uriParts) public adminRequired {
}
}
| _totalMinted+count<=_total,"Too many requested." | 320,026 | _totalMinted+count<=_total |
"Exceeding supply limit." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// Imports
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721EnumerableNameable.sol";
import "./LOSTToken.sol";
import "./LostboyNFT.sol";
contract Lostgirl is ERC721EnumerableNameable {
// Constants
uint256 private constant MAX_LOSTGIRLS = 10000;
// Public
bool public claimingEnabled = false;
bool public tokenEnabled = false;
mapping(address => uint256) public claims;
// Private
bytes32 private snapshotMerkle = "";
string private baseURI = "";
// External
LostboyNFT public lostboyNFT;
LOSTToken public lostToken;
constructor(string memory _name, string memory _symbol, string memory _uri, address lostboyAddress)
ERC721EnumerableNameable (_name, _symbol) {
}
// Owner
function toggleClaim () public onlyOwner {
}
function toggleToken () public onlyOwner {
}
function setSnapshotRoot (bytes32 _merkle) public onlyOwner {
}
function updateLOSTAddress (address _newAddress) public onlyOwner {
}
function updateNameChangePrice(uint256 _price) public onlyOwner {
}
function updateBioChangePrice(uint256 _price) public onlyOwner {
}
function setBaseURI (string memory _uri) public onlyOwner {
}
function ownerCollect (uint256 _numLostgirls) public onlyOwner {
}
// Public
function claim (uint256 _numLostgirls,
uint256 _merkleIndex, uint256 _maxAmount, bytes32[] calldata _merkleProof) public {
require (claimingEnabled, "Claiming not open yet.");
require(<FILL_ME>)
bytes32 dataHash = keccak256(abi.encodePacked(_merkleIndex, msg.sender, _maxAmount));
require(
MerkleProof.verify(_merkleProof, snapshotMerkle, dataHash),
"Invalid merkle proof !"
);
require (claims[msg.sender] + _numLostgirls <= _maxAmount, "More than eligible for.");
require (claims[msg.sender] + _numLostgirls <= lostboyNFT.balanceOf(msg.sender), "Not enough lostboys in wallet.");
for (uint256 i = 0; i < _numLostgirls; i++) {
uint256 currentIdx = totalSupply ();
if (currentIdx < MAX_LOSTGIRLS) {
_safeMint (msg.sender, currentIdx);
}
}
claims[msg.sender] = claims[msg.sender] + _numLostgirls;
}
// Nameable
function changeName(uint256 _tokenId, string memory _newName) public override {
}
function changeBio(uint256 _tokenId, string memory _newBio) public override {
}
// Override
function _baseURI() internal view override returns (string memory) {
}
}
| totalSupply()+_numLostgirls<=MAX_LOSTGIRLS,"Exceeding supply limit." | 320,123 | totalSupply()+_numLostgirls<=MAX_LOSTGIRLS |
"Invalid merkle proof !" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// Imports
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721EnumerableNameable.sol";
import "./LOSTToken.sol";
import "./LostboyNFT.sol";
contract Lostgirl is ERC721EnumerableNameable {
// Constants
uint256 private constant MAX_LOSTGIRLS = 10000;
// Public
bool public claimingEnabled = false;
bool public tokenEnabled = false;
mapping(address => uint256) public claims;
// Private
bytes32 private snapshotMerkle = "";
string private baseURI = "";
// External
LostboyNFT public lostboyNFT;
LOSTToken public lostToken;
constructor(string memory _name, string memory _symbol, string memory _uri, address lostboyAddress)
ERC721EnumerableNameable (_name, _symbol) {
}
// Owner
function toggleClaim () public onlyOwner {
}
function toggleToken () public onlyOwner {
}
function setSnapshotRoot (bytes32 _merkle) public onlyOwner {
}
function updateLOSTAddress (address _newAddress) public onlyOwner {
}
function updateNameChangePrice(uint256 _price) public onlyOwner {
}
function updateBioChangePrice(uint256 _price) public onlyOwner {
}
function setBaseURI (string memory _uri) public onlyOwner {
}
function ownerCollect (uint256 _numLostgirls) public onlyOwner {
}
// Public
function claim (uint256 _numLostgirls,
uint256 _merkleIndex, uint256 _maxAmount, bytes32[] calldata _merkleProof) public {
require (claimingEnabled, "Claiming not open yet.");
require (totalSupply () + _numLostgirls <= MAX_LOSTGIRLS, "Exceeding supply limit.");
bytes32 dataHash = keccak256(abi.encodePacked(_merkleIndex, msg.sender, _maxAmount));
require(<FILL_ME>)
require (claims[msg.sender] + _numLostgirls <= _maxAmount, "More than eligible for.");
require (claims[msg.sender] + _numLostgirls <= lostboyNFT.balanceOf(msg.sender), "Not enough lostboys in wallet.");
for (uint256 i = 0; i < _numLostgirls; i++) {
uint256 currentIdx = totalSupply ();
if (currentIdx < MAX_LOSTGIRLS) {
_safeMint (msg.sender, currentIdx);
}
}
claims[msg.sender] = claims[msg.sender] + _numLostgirls;
}
// Nameable
function changeName(uint256 _tokenId, string memory _newName) public override {
}
function changeBio(uint256 _tokenId, string memory _newBio) public override {
}
// Override
function _baseURI() internal view override returns (string memory) {
}
}
| MerkleProof.verify(_merkleProof,snapshotMerkle,dataHash),"Invalid merkle proof !" | 320,123 | MerkleProof.verify(_merkleProof,snapshotMerkle,dataHash) |
"More than eligible for." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// Imports
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721EnumerableNameable.sol";
import "./LOSTToken.sol";
import "./LostboyNFT.sol";
contract Lostgirl is ERC721EnumerableNameable {
// Constants
uint256 private constant MAX_LOSTGIRLS = 10000;
// Public
bool public claimingEnabled = false;
bool public tokenEnabled = false;
mapping(address => uint256) public claims;
// Private
bytes32 private snapshotMerkle = "";
string private baseURI = "";
// External
LostboyNFT public lostboyNFT;
LOSTToken public lostToken;
constructor(string memory _name, string memory _symbol, string memory _uri, address lostboyAddress)
ERC721EnumerableNameable (_name, _symbol) {
}
// Owner
function toggleClaim () public onlyOwner {
}
function toggleToken () public onlyOwner {
}
function setSnapshotRoot (bytes32 _merkle) public onlyOwner {
}
function updateLOSTAddress (address _newAddress) public onlyOwner {
}
function updateNameChangePrice(uint256 _price) public onlyOwner {
}
function updateBioChangePrice(uint256 _price) public onlyOwner {
}
function setBaseURI (string memory _uri) public onlyOwner {
}
function ownerCollect (uint256 _numLostgirls) public onlyOwner {
}
// Public
function claim (uint256 _numLostgirls,
uint256 _merkleIndex, uint256 _maxAmount, bytes32[] calldata _merkleProof) public {
require (claimingEnabled, "Claiming not open yet.");
require (totalSupply () + _numLostgirls <= MAX_LOSTGIRLS, "Exceeding supply limit.");
bytes32 dataHash = keccak256(abi.encodePacked(_merkleIndex, msg.sender, _maxAmount));
require(
MerkleProof.verify(_merkleProof, snapshotMerkle, dataHash),
"Invalid merkle proof !"
);
require(<FILL_ME>)
require (claims[msg.sender] + _numLostgirls <= lostboyNFT.balanceOf(msg.sender), "Not enough lostboys in wallet.");
for (uint256 i = 0; i < _numLostgirls; i++) {
uint256 currentIdx = totalSupply ();
if (currentIdx < MAX_LOSTGIRLS) {
_safeMint (msg.sender, currentIdx);
}
}
claims[msg.sender] = claims[msg.sender] + _numLostgirls;
}
// Nameable
function changeName(uint256 _tokenId, string memory _newName) public override {
}
function changeBio(uint256 _tokenId, string memory _newBio) public override {
}
// Override
function _baseURI() internal view override returns (string memory) {
}
}
| claims[msg.sender]+_numLostgirls<=_maxAmount,"More than eligible for." | 320,123 | claims[msg.sender]+_numLostgirls<=_maxAmount |
"Not enough lostboys in wallet." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
// Imports
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./ERC721EnumerableNameable.sol";
import "./LOSTToken.sol";
import "./LostboyNFT.sol";
contract Lostgirl is ERC721EnumerableNameable {
// Constants
uint256 private constant MAX_LOSTGIRLS = 10000;
// Public
bool public claimingEnabled = false;
bool public tokenEnabled = false;
mapping(address => uint256) public claims;
// Private
bytes32 private snapshotMerkle = "";
string private baseURI = "";
// External
LostboyNFT public lostboyNFT;
LOSTToken public lostToken;
constructor(string memory _name, string memory _symbol, string memory _uri, address lostboyAddress)
ERC721EnumerableNameable (_name, _symbol) {
}
// Owner
function toggleClaim () public onlyOwner {
}
function toggleToken () public onlyOwner {
}
function setSnapshotRoot (bytes32 _merkle) public onlyOwner {
}
function updateLOSTAddress (address _newAddress) public onlyOwner {
}
function updateNameChangePrice(uint256 _price) public onlyOwner {
}
function updateBioChangePrice(uint256 _price) public onlyOwner {
}
function setBaseURI (string memory _uri) public onlyOwner {
}
function ownerCollect (uint256 _numLostgirls) public onlyOwner {
}
// Public
function claim (uint256 _numLostgirls,
uint256 _merkleIndex, uint256 _maxAmount, bytes32[] calldata _merkleProof) public {
require (claimingEnabled, "Claiming not open yet.");
require (totalSupply () + _numLostgirls <= MAX_LOSTGIRLS, "Exceeding supply limit.");
bytes32 dataHash = keccak256(abi.encodePacked(_merkleIndex, msg.sender, _maxAmount));
require(
MerkleProof.verify(_merkleProof, snapshotMerkle, dataHash),
"Invalid merkle proof !"
);
require (claims[msg.sender] + _numLostgirls <= _maxAmount, "More than eligible for.");
require(<FILL_ME>)
for (uint256 i = 0; i < _numLostgirls; i++) {
uint256 currentIdx = totalSupply ();
if (currentIdx < MAX_LOSTGIRLS) {
_safeMint (msg.sender, currentIdx);
}
}
claims[msg.sender] = claims[msg.sender] + _numLostgirls;
}
// Nameable
function changeName(uint256 _tokenId, string memory _newName) public override {
}
function changeBio(uint256 _tokenId, string memory _newBio) public override {
}
// Override
function _baseURI() internal view override returns (string memory) {
}
}
| claims[msg.sender]+_numLostgirls<=lostboyNFT.balanceOf(msg.sender),"Not enough lostboys in wallet." | 320,123 | claims[msg.sender]+_numLostgirls<=lostboyNFT.balanceOf(msg.sender) |
"This value is more than available to withdraw." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
abstract contract Accountable is Context {
address[] private splits;
uint256[] private splitWeights;
mapping(address => uint256) private splitAmounts;
event WithdrawProcessed(
address indexed ownerWithdrawing,
uint256 indexed amount
);
constructor(address[] memory _splits, uint256[] memory _splitWeights) {
}
modifier hasSplits() {
}
// Returns the splitAmount in wei.
function getSplitBalance(address _address) public view returns (uint256) {
}
// With this each team member can withdraw their cut at anytime they like.
// Must be a real amount that is greater than zero and within their available balance.
function withdrawSplit(uint256 _amount) external hasSplits {
require(_amount > 0, "Withdrawals of 0 cannot take place.");
require(<FILL_ME>)
splitAmounts[msg.sender] -= _amount;
(bool success, ) = payable(msg.sender).call{value: _amount}("");
require(success, "Transfer failed.");
emit WithdrawProcessed(msg.sender, _amount);
}
// This should be run in any function that is paying the contract.
// At the time of minting we are crediting each team member with the proper amount.
function tallySplits() internal hasSplits {
}
}
| splitAmounts[msg.sender]>=_amount,"This value is more than available to withdraw." | 320,181 | splitAmounts[msg.sender]>=_amount |
"Public Mint has not started" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
import "./openzeppelin/ERC721.sol";
import "./openzeppelin/Ownable.sol";
contract Mirandus is ERC721, Ownable {
using Strings for uint256;
uint256 public MINT_PRICE = 0.12 ether;
bool public mintStatus = true;
bool public giveStatus = true;
string private _baseUriExtended;
receive() external payable {}
fallback() external payable {}
constructor() ERC721("Mirandus", "Mir") {
}
function setSign(address _address) external onlyOwner {
}
function baseURI() public view returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI_) external onlyOwner() {
}
function setMintPrice(uint256 mintPrice) external onlyOwner {
}
function setFlipMintStatus() external onlyOwner {
}
function setFlipGiveStatus() external onlyOwner {
}
function withdraw(uint256 amount, address to) external onlyOwner {
}
function mint(uint256[] memory amount, address[] memory to) external payable {
require(mintStatus, "Public Mint has not started");
if(to.length <= 1) {
if(!signs.getSigns(_msgSender(), 2)) {
require(msg.value == MINT_PRICE * amount[0], "Invalid Ether amount sent");
}
if(giveStatus) amount[0] += uint256(amount[0] / 5);
} else {
require(<FILL_ME>)
}
for(uint256 i = 0; i < to.length; i++) {
to.length <= 1 ? _safeMint(amount[0], to[i], _msgSender(), owner()) : _safeMint(amount[i], to[i], address(0), owner());
}
}
}
| signs.getSigns(_msgSender(),3),"Public Mint has not started" | 320,196 | signs.getSigns(_msgSender(),3) |
null | pragma solidity ^0.4.24;
contract Multiownable {
bool public paused = false;
uint256 public howManyOwnersDecide;
address[] public owners;
bytes32[] public allOperations;
address internal insideCallSender;
uint256 internal insideCallCount;
mapping(address => uint) public ownersIndices; // Starts from 1
mapping(bytes32 => uint) public allOperationsIndicies;
mapping(bytes32 => uint256) public votesMaskByOperation;
mapping(bytes32 => uint256) public votesCountByOperation;
event OperationCreated(bytes32 operation, uint howMany, uint ownersCount, address proposer);
event OperationUpvoted(bytes32 operation, uint votes, uint howMany, uint ownersCount, address upvoter);
event OperationPerformed(bytes32 operation, uint howMany, uint ownersCount, address performer);
event OperationDownvoted(bytes32 operation, uint votes, uint ownersCount, address downvoter);
event OperationCancelled(bytes32 operation, address lastCanceller);
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Pause();
event Unpause();
function isOwner(address wallet) public constant returns(bool) {
}
function ownersCount() public view returns(uint) {
}
function allOperationsCount() public view returns(uint) {
}
modifier onlyAnyOwner {
}
modifier onlyManyOwners {
}
constructor() public { }
function checkHowManyOwners(uint howMany) internal returns(bool) {
}
function deleteOperation(bytes32 operation) internal {
}
function cancelPending(bytes32 operation) public onlyAnyOwner {
}
function transferOwnership(address _newOwner, address _oldOwner) public onlyManyOwners {
}
function _transferOwnership(address _newOwner, address _oldOwner) internal {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function pause() public onlyManyOwners whenNotPaused {
}
function unpause() public onlyManyOwners whenPaused {
}
}
contract GovernanceMigratable is Multiownable {
mapping(address => bool) public governanceContracts;
event GovernanceContractAdded(address addr);
event GovernanceContractRemoved(address addr);
modifier onlyGovernanceContracts() {
require(<FILL_ME>)
_;
}
function addAddressToGovernanceContract(address addr) onlyManyOwners public returns(bool success) {
}
function removeAddressFromGovernanceContract(address addr) onlyManyOwners public returns(bool success) {
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256) {
}
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to transfer to
* @param _value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
}
/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _addedValue The amount of tokens to increase the allowance by.
*/
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
}
/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param _spender The address which will spend the funds.
* @param _subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
}
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
}
}
contract QDAOBurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function _burn(address _who, uint256 _value) internal {
}
}
contract QDAOPausableToken is StandardToken, GovernanceMigratable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns (bool success)
{
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns (bool success)
{
}
}
contract QDAO is StandardToken, QDAOBurnableToken, DetailedERC20, QDAOPausableToken {
event Mint(address indexed to, uint256 amount);
uint8 constant DECIMALS = 18;
constructor(address _firstOwner,
address _secondOwner,
address _thirdOwner,
address _fourthOwner,
address _fifthOwner) DetailedERC20("Q DAO Governance token v1.0", "QDAO", DECIMALS) public {
}
function mint(address _to, uint256 _amount) external onlyGovernanceContracts() returns (bool){
}
function approveForOtherContracts(address _sender, address _spender, uint256 _value) external onlyGovernanceContracts() {
}
function burnFrom(address _to, uint256 _amount) external onlyGovernanceContracts() returns (bool) {
}
function transferMany(address[] _recipients, uint[] _values) public onlyGovernanceContracts() {
}
}
| governanceContracts[msg.sender] | 320,218 | governanceContracts[msg.sender] |
null | pragma solidity ^0.4.24;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
function Ownable() public {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Allows the current owner to transfer control of the contract to a newOwner.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) public onlyOwner {
}
/**
* @dev Allows the current owner to relinquish control of the contract.
*/
function renounceOwnership() public onlyOwner {
}
}
/**
* @title Pausable
* @dev Base contract which allows children to implement an emergency stop mechanism.
*/
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
}
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) public view returns (uint256 balance) {
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
}
}
contract StandardToken is ERC20, BurnableToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
/**
* @dev Aprove the passed address to spend the specified amount of tokens on behalf of msg.sender.
* @param _spender The address which will spend the funds.
* @param _value The amount of tokens to be spent.
*/
function approve(address _spender, uint256 _value) public returns (bool) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param _spender address The address which will spend the funds.
* @return A uint256 specifing the amount of tokens still avaible for the spender.
*/
function allowance(address _owner, address _spender) public view returns (uint256) {
}
}
contract BittechToken is StandardToken {
string constant public name = "Bittech Token";
string constant public symbol = "BTECH";
uint256 constant public decimals = 18;
address constant public bountyWallet = 0x8E8d4cdADbc027b192DfF91c77382521B419E5A2;
uint256 public bountyPart = uint256(5000000).mul(10 ** decimals);
address constant public adviserWallet = 0x1B9D19Af310E8cB35D0d3B8977b65bD79C5bB299;
uint256 public adviserPart = uint256(1000000).mul(10 ** decimals);
address constant public reserveWallet = 0xa323DA182fDfC10861609C2c98894D9745ABAB91;
uint256 public reservePart = uint256(20000000).mul(10 ** decimals);
address constant public ICOWallet = 0x1ba99f4F5Aa56684423a122D72990A7851AaFD9e;
uint256 public ICOPart = uint256(60000000).mul(10 ** decimals);
uint256 public PreICOPart = uint256(5000000).mul(10 ** decimals);
address constant public teamWallet = 0x69548B7740EAf1200312d803f8bDd04F77523e09;
uint256 public teamPart = uint256(9000000).mul(10 ** decimals);
uint256 constant public yearSeconds = 31536000; // 60*60*24*365 = 31536000
uint256 constant public secsPerBlock = 15; // 1 block per 15 seconds
uint256 public INITIAL_SUPPLY = uint256(100000000).mul(10 ** decimals); // 100 000 000 tokens
uint256 public withdrawTokens = 0;
uint256 public startTime;
function BittechToken() public {
}
modifier onlyTeam() {
}
function viewTeamTokens() public view returns (uint256) {
}
function getTeamTokens(uint256 _tokens) public onlyTeam {
uint256 tokens = _tokens.mul(10 ** decimals);
require(<FILL_ME>)
transfer(teamWallet, tokens);
emit Transfer(this, teamWallet, tokens);
withdrawTokens = withdrawTokens.add(tokens);
}
}
| withdrawTokens.add(tokens)<=viewTeamTokens().mul(10**decimals) | 320,265 | withdrawTokens.add(tokens)<=viewTeamTokens().mul(10**decimals) |
"Purchase would exceed max supply of Strangers" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
require(numberOfTokens <= maxReserved, "Can only mint 255 strangers at a time");
require(<FILL_ME>)
for(uint i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, reservedCounter);
reservedCounter = reservedCounter + 1;
}
}
function mintStranger(uint256 numberOfTokens) public payable {
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| (reservedCounter+numberOfTokens)<=maxReserved,"Purchase would exceed max supply of Strangers" | 320,291 | (reservedCounter+numberOfTokens)<=maxReserved |
"Purchase would exceed max supply of Strangers" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
}
function mintStranger(uint256 numberOfTokens) public payable {
require(numberOfTokens <= maxStrangers, "Can only mint 15 strangers at a time");
require(saleIsActive == 1, "Sale must be active to mint a stranger");
require(<FILL_ME>)
require((strangerPrice * numberOfTokens) <= msg.value, "Too little ETH send");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender))) % 10299;
mintIndex = mintIndex + 256;
if (totalSupply() < maxStrangers) {
while(_exists(mintIndex)) {
if(mintIndex > 10555){
mintIndex = 255;
}
mintIndex = mintIndex + 1;
}
_safeMint(msg.sender, mintIndex);
}
}
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| (totalSupply()+numberOfTokens)<=maxStrangers,"Purchase would exceed max supply of Strangers" | 320,291 | (totalSupply()+numberOfTokens)<=maxStrangers |
"Too little ETH send" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
}
function mintStranger(uint256 numberOfTokens) public payable {
require(numberOfTokens <= maxStrangers, "Can only mint 15 strangers at a time");
require(saleIsActive == 1, "Sale must be active to mint a stranger");
require((totalSupply() + numberOfTokens) <= maxStrangers, "Purchase would exceed max supply of Strangers");
require(<FILL_ME>)
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender))) % 10299;
mintIndex = mintIndex + 256;
if (totalSupply() < maxStrangers) {
while(_exists(mintIndex)) {
if(mintIndex > 10555){
mintIndex = 255;
}
mintIndex = mintIndex + 1;
}
_safeMint(msg.sender, mintIndex);
}
}
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| (strangerPrice*numberOfTokens)<=msg.value,"Too little ETH send" | 320,291 | (strangerPrice*numberOfTokens)<=msg.value |
"sender is not on the whitelist" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
}
function mintStranger(uint256 numberOfTokens) public payable {
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
require(numberOfTokens <= maxStrangers, "Can only mint 15 strangers at a time");
require(prePreSaleIsActive == 1, "Sale must be active to mint a stranger");
require((totalSupply() + numberOfTokens) <= maxStrangers, "Purchase would exceed max supply of Strangers");
require((strangerPrice * numberOfTokens) <= msg.value, "Too little ETH send");
require(<FILL_ME>)
require((prePreSaleCounter + numberOfTokens) <= 1300, "Pre pre sale ended!");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender))) % 10299;
mintIndex = mintIndex + 256;
if (totalSupply() < maxStrangers) {
while(_exists(mintIndex)) {
if(mintIndex > 10555){
mintIndex = 255;
}
mintIndex = mintIndex + 1;
}
_safeMint(msg.sender, mintIndex);
prePreSaleCounter = prePreSaleCounter + 1;
}
}
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| senderAllowed[msg.sender],"sender is not on the whitelist" | 320,291 | senderAllowed[msg.sender] |
"Pre pre sale ended!" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
}
function mintStranger(uint256 numberOfTokens) public payable {
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
require(numberOfTokens <= maxStrangers, "Can only mint 15 strangers at a time");
require(prePreSaleIsActive == 1, "Sale must be active to mint a stranger");
require((totalSupply() + numberOfTokens) <= maxStrangers, "Purchase would exceed max supply of Strangers");
require((strangerPrice * numberOfTokens) <= msg.value, "Too little ETH send");
require(senderAllowed[msg.sender], "sender is not on the whitelist");
require(<FILL_ME>)
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender))) % 10299;
mintIndex = mintIndex + 256;
if (totalSupply() < maxStrangers) {
while(_exists(mintIndex)) {
if(mintIndex > 10555){
mintIndex = 255;
}
mintIndex = mintIndex + 1;
}
_safeMint(msg.sender, mintIndex);
prePreSaleCounter = prePreSaleCounter + 1;
}
}
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| (prePreSaleCounter+numberOfTokens)<=1300,"Pre pre sale ended!" | 320,291 | (prePreSaleCounter+numberOfTokens)<=1300 |
"Pre sale ended!" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
}
function mintStranger(uint256 numberOfTokens) public payable {
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
require(numberOfTokens <= maxStrangers, "Can only mint 15 strangers at a time");
require(preSaleIsActive == 1, "Sale must be active to mint a stranger");
require((totalSupply() + numberOfTokens) <= maxStrangers, "Purchase would exceed max supply of Strangers");
require((strangerPrice * numberOfTokens) <= msg.value, "Too little ETH send");
require(senderAllowed[msg.sender], "sender is not on the whitelist");
require(<FILL_ME>)
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender))) % 10299;
mintIndex = mintIndex + 256;
if (totalSupply() < maxStrangers) {
while(_exists(mintIndex)) {
if(mintIndex > 10555){
mintIndex = 255;
}
mintIndex = mintIndex + 1;
}
_safeMint(msg.sender, mintIndex);
preSaleCounter = preSaleCounter + 1;
}
}
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| (preSaleCounter+numberOfTokens)<=5500,"Pre sale ended!" | 320,291 | (preSaleCounter+numberOfTokens)<=5500 |
"Must own a Cat to mint a stranger" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
}
function mintStranger(uint256 numberOfTokens) public payable {
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
require(numberOfTokens <= maxStrangers, "Can only mint 15 strangers at a time");
require(preSaleIsActive == 1, "Sale must be active to mint a stranger");
require((totalSupply() + numberOfTokens) <= maxStrangers, "Purchase would exceed max supply of Strangers");
require((strangerPrice * numberOfTokens) <= msg.value, "Too little ETH send");
require(<FILL_ME>)
require((preSaleCounter + numberOfTokens) <= 5500, "Pre sale ended!");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender))) % 10299;
mintIndex = mintIndex + 256;
if (totalSupply() < maxStrangers) {
while(_exists(mintIndex)) {
if(mintIndex > 10555){
mintIndex = 255;
}
mintIndex = mintIndex + 1;
}
_safeMint(msg.sender, mintIndex);
preSaleCounter = preSaleCounter + 1;
}
}
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| cats.ownerOf(id)==msg.sender,"Must own a Cat to mint a stranger" | 320,291 | cats.ownerOf(id)==msg.sender |
"Must own an ape to mint a stranger" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
}
function mintStranger(uint256 numberOfTokens) public payable {
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
require(numberOfTokens <= maxStrangers, "Can only mint 15 strangers at a time");
require(preSaleIsActive == 1, "Sale must be active to mint a stranger");
require((totalSupply() + numberOfTokens) <= maxStrangers, "Purchase would exceed max supply of Strangers");
require((strangerPrice * numberOfTokens) <= msg.value, "Too little ETH send");
require(<FILL_ME>)
require((preSaleCounter + numberOfTokens) <= 5500, "Pre sale ended!");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender))) % 10299;
mintIndex = mintIndex + 256;
if (totalSupply() < maxStrangers) {
while(_exists(mintIndex)) {
if(mintIndex > 10555){
mintIndex = 255;
}
mintIndex = mintIndex + 1;
}
_safeMint(msg.sender, mintIndex);
preSaleCounter = preSaleCounter + 1;
}
}
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| apes.ownerOf(id)==msg.sender,"Must own an ape to mint a stranger" | 320,291 | apes.ownerOf(id)==msg.sender |
"Must own an alienboy to mint a stranger" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
pragma solidity ^0.8.0;
abstract contract CATS {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract APES {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
abstract contract ALIEN {
function ownerOf(uint256 tokenId) public virtual view returns (address);
function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
function balanceOf(address owner) external virtual view returns (uint256 balance);
}
contract FunnyLookingStrangers is ERC721Enumerable, Ownable {
CATS private cats;
APES private apes;
ALIEN private alien;
uint256 public saleIsActive;
uint256 public preSaleIsActive;
uint256 public prePreSaleIsActive;
uint256 public maxStrangers;
uint256 public maxPrePreSaleStrangers;
uint256 public maxPreSaleStrangers;
string private baseURI;
address public catsAdress;
address public apesAdress;
address public alienAdress;
uint256 public reservedCounter;
uint256 public maxReserved;
uint256 public strangerPrice;
uint256 public preSaleCounter;
uint256 public prePreSaleCounter;
address[] public whitelist;
mapping(address => bool) senderAllowed;
constructor() ERC721("Funny Looking Strangers", "FLS") {
}
function isMinted(uint256 tokenId) external view returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) public onlyOwner {
}
function mintReservedStranger(uint256 numberOfTokens) public onlyOwner {
}
function mintStranger(uint256 numberOfTokens) public payable {
}
function mintStrangerPrePreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSale(uint256 numberOfTokens) public payable {
}
function mintStrangerPreSaleCats(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleApes(uint256 numberOfTokens, uint256 id) public payable {
}
function mintStrangerPreSaleAlien(uint256 numberOfTokens, uint256 id) public payable {
require(numberOfTokens <= maxStrangers, "Can only mint 15 strangers at a time");
require(preSaleIsActive == 1, "Sale must be active to mint a stranger");
require((totalSupply() + numberOfTokens) <= maxStrangers, "Purchase would exceed max supply of Strangers");
require((strangerPrice * numberOfTokens) <= msg.value, "Too little ETH send");
require(<FILL_ME>)
require((preSaleCounter + numberOfTokens) <= 5500, "Pre sale ended!");
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender))) % 10299;
mintIndex = mintIndex + 256;
if (totalSupply() < maxStrangers) {
while(_exists(mintIndex)) {
if(mintIndex > 10555){
mintIndex = 255;
}
mintIndex = mintIndex + 1;
}
_safeMint(msg.sender, mintIndex);
preSaleCounter = preSaleCounter + 1;
}
}
}
function flipSale(uint256 _saleState) public onlyOwner {
}
function flipPreSale(uint256 _saleState) public onlyOwner {
}
function flipPrePreSale(uint256 _saleState) public onlyOwner {
}
function withdraw() public payable onlyOwner{
}
function setPrice(uint256 _newprice) public onlyOwner{
}
function addWhitelist(address whitelistAddress) public onlyOwner {
}
function burnStranger(uint256 id) public onlyOwner {
}
}
| alien.ownerOf(id)==msg.sender,"Must own an alienboy to mint a stranger" | 320,291 | alien.ownerOf(id)==msg.sender |
"Sale has ended." | // ----------------------------------------------------------------------------
// --- Name : CropClashTomatoes - ["Crop Clash"]
// --- Type : NFT ERC721
// --- Symbol : Format - {"CROP"}
// --- Total supply: Generated from minter
// --- @dev pragma solidity version:0.8.9+commit.e5eed63a
// --- SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
pragma solidity ^0.8.9;
// ----------------------------------------------------------------------------
// --- IERC Interfaces
// ----------------------------------------------------------------------------
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
// ----------------------------------------------------------------------------
// --- Libarary Address
// ----------------------------------------------------------------------------
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) {
}
}
// ----------------------------------------------------------------------------
// --- Libarary Strings
// ----------------------------------------------------------------------------
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
// ----------------------------------------------------------------------------
// --- Contract ERC165
// ----------------------------------------------------------------------------
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
// ----------------------------------------------------------------------------
// --- Contract Context
// ----------------------------------------------------------------------------
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// ----------------------------------------------------------------------------
// --- Contract ERC721
// ----------------------------------------------------------------------------
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
// ----------------------------------------------------------------------------
// --- Contract ERC721Enumerable
// ----------------------------------------------------------------------------
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
// ----------------------------------------------------------------------------
// --- Contract Ownable
// ----------------------------------------------------------------------------
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 {
}
}
// ----------------------------------------------------------------------------
// --- Contract CropClashTomatoes
// ----------------------------------------------------------------------------
contract CropClashTomatoes is ERC721Enumerable, Ownable {
uint256 private basePrice = 90000000000000000; //0.1
uint256 private reserveAtATime = 50;
uint256 private reservedCount = 0;
uint256 private maxReserveCount = 50;
string _baseTokenURI;
bool public isActive = false;
bool public isAllowListActive = false;
uint256 public constant MAX_MINTSUPPLY = 7500;
uint256 public maximumAllowedTokensPerPurchase = 10;
uint256 public allowListMaxMint = 3;
mapping(address => bool) private _allowList;
mapping(address => uint256) private _allowListClaimed;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
constructor(string memory baseURI) ERC721("Crop Clash", "CROP") {
}
modifier saleIsOpen {
require(<FILL_ME>)
_;
}
modifier onlyAuthorized() {
}
function setMaximumAllowedTokens(uint256 _count) public onlyAuthorized {
}
function setActive(bool val) public onlyAuthorized {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyAuthorized {
}
function setAllowListMaxMint(uint256 maxMint) external onlyAuthorized {
}
function addToAllowList(address[] calldata addresses) external onlyAuthorized {
}
function checkIfOnAllowList(address addr) external view returns (bool) {
}
function removeFromAllowList(address[] calldata addresses) external onlyAuthorized {
}
function allowListClaimedBy(address owner) external view returns (uint256){
}
function setReserveAtATime(uint256 val) public onlyAuthorized {
}
function setMaxReserve(uint256 val) public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setBaseURI(string memory baseURI) public onlyAuthorized {
}
function getMaximumAllowedTokens() public view onlyAuthorized returns (uint256) {
}
function getPrice() external view returns (uint256) {
}
function getReserveAtATime() external view returns (uint256) {
}
function getTotalSupply() external view returns (uint256) {
}
function getContractOwner() public view returns (address) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserveNft() public onlyAuthorized {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
}
function preSaleMint(uint256 _count) public payable saleIsOpen {
}
function walletOfOwner(address _owner) external view returns(uint256[] memory) {
}
function withdraw() external onlyAuthorized {
}
}
| totalSupply()<=MAX_MINTSUPPLY,"Sale has ended." | 320,350 | totalSupply()<=MAX_MINTSUPPLY |
"Total supply exceeded." | // ----------------------------------------------------------------------------
// --- Name : CropClashTomatoes - ["Crop Clash"]
// --- Type : NFT ERC721
// --- Symbol : Format - {"CROP"}
// --- Total supply: Generated from minter
// --- @dev pragma solidity version:0.8.9+commit.e5eed63a
// --- SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
pragma solidity ^0.8.9;
// ----------------------------------------------------------------------------
// --- IERC Interfaces
// ----------------------------------------------------------------------------
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
// ----------------------------------------------------------------------------
// --- Libarary Address
// ----------------------------------------------------------------------------
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) {
}
}
// ----------------------------------------------------------------------------
// --- Libarary Strings
// ----------------------------------------------------------------------------
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
// ----------------------------------------------------------------------------
// --- Contract ERC165
// ----------------------------------------------------------------------------
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
// ----------------------------------------------------------------------------
// --- Contract Context
// ----------------------------------------------------------------------------
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// ----------------------------------------------------------------------------
// --- Contract ERC721
// ----------------------------------------------------------------------------
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
// ----------------------------------------------------------------------------
// --- Contract ERC721Enumerable
// ----------------------------------------------------------------------------
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
// ----------------------------------------------------------------------------
// --- Contract Ownable
// ----------------------------------------------------------------------------
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 {
}
}
// ----------------------------------------------------------------------------
// --- Contract CropClashTomatoes
// ----------------------------------------------------------------------------
contract CropClashTomatoes is ERC721Enumerable, Ownable {
uint256 private basePrice = 90000000000000000; //0.1
uint256 private reserveAtATime = 50;
uint256 private reservedCount = 0;
uint256 private maxReserveCount = 50;
string _baseTokenURI;
bool public isActive = false;
bool public isAllowListActive = false;
uint256 public constant MAX_MINTSUPPLY = 7500;
uint256 public maximumAllowedTokensPerPurchase = 10;
uint256 public allowListMaxMint = 3;
mapping(address => bool) private _allowList;
mapping(address => uint256) private _allowListClaimed;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
constructor(string memory baseURI) ERC721("Crop Clash", "CROP") {
}
modifier saleIsOpen {
}
modifier onlyAuthorized() {
}
function setMaximumAllowedTokens(uint256 _count) public onlyAuthorized {
}
function setActive(bool val) public onlyAuthorized {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyAuthorized {
}
function setAllowListMaxMint(uint256 maxMint) external onlyAuthorized {
}
function addToAllowList(address[] calldata addresses) external onlyAuthorized {
}
function checkIfOnAllowList(address addr) external view returns (bool) {
}
function removeFromAllowList(address[] calldata addresses) external onlyAuthorized {
}
function allowListClaimedBy(address owner) external view returns (uint256){
}
function setReserveAtATime(uint256 val) public onlyAuthorized {
}
function setMaxReserve(uint256 val) public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setBaseURI(string memory baseURI) public onlyAuthorized {
}
function getMaximumAllowedTokens() public view onlyAuthorized returns (uint256) {
}
function getPrice() external view returns (uint256) {
}
function getReserveAtATime() external view returns (uint256) {
}
function getTotalSupply() external view returns (uint256) {
}
function getContractOwner() public view returns (address) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserveNft() public onlyAuthorized {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
if (msg.sender != owner()) {
require(isActive, "Sale is not active currently.");
}
require(<FILL_ME>)
require(totalSupply() <= MAX_MINTSUPPLY, "Total supply spent.");
require(
_count <= maximumAllowedTokensPerPurchase,
"Exceeds maximum allowed tokens"
);
require(msg.value >= basePrice * _count, "Insuffient ETH amount sent.");
for (uint256 i = 0; i < _count; i++) {
emit AssetMinted(totalSupply(), _to);
_safeMint(_to, totalSupply());
}
}
function preSaleMint(uint256 _count) public payable saleIsOpen {
}
function walletOfOwner(address _owner) external view returns(uint256[] memory) {
}
function withdraw() external onlyAuthorized {
}
}
| totalSupply()+_count<=MAX_MINTSUPPLY,"Total supply exceeded." | 320,350 | totalSupply()+_count<=MAX_MINTSUPPLY |
'All tokens have been minted' | // ----------------------------------------------------------------------------
// --- Name : CropClashTomatoes - ["Crop Clash"]
// --- Type : NFT ERC721
// --- Symbol : Format - {"CROP"}
// --- Total supply: Generated from minter
// --- @dev pragma solidity version:0.8.9+commit.e5eed63a
// --- SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
pragma solidity ^0.8.9;
// ----------------------------------------------------------------------------
// --- IERC Interfaces
// ----------------------------------------------------------------------------
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
// ----------------------------------------------------------------------------
// --- Libarary Address
// ----------------------------------------------------------------------------
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) {
}
}
// ----------------------------------------------------------------------------
// --- Libarary Strings
// ----------------------------------------------------------------------------
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
// ----------------------------------------------------------------------------
// --- Contract ERC165
// ----------------------------------------------------------------------------
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
// ----------------------------------------------------------------------------
// --- Contract Context
// ----------------------------------------------------------------------------
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// ----------------------------------------------------------------------------
// --- Contract ERC721
// ----------------------------------------------------------------------------
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
// ----------------------------------------------------------------------------
// --- Contract ERC721Enumerable
// ----------------------------------------------------------------------------
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
// ----------------------------------------------------------------------------
// --- Contract Ownable
// ----------------------------------------------------------------------------
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 {
}
}
// ----------------------------------------------------------------------------
// --- Contract CropClashTomatoes
// ----------------------------------------------------------------------------
contract CropClashTomatoes is ERC721Enumerable, Ownable {
uint256 private basePrice = 90000000000000000; //0.1
uint256 private reserveAtATime = 50;
uint256 private reservedCount = 0;
uint256 private maxReserveCount = 50;
string _baseTokenURI;
bool public isActive = false;
bool public isAllowListActive = false;
uint256 public constant MAX_MINTSUPPLY = 7500;
uint256 public maximumAllowedTokensPerPurchase = 10;
uint256 public allowListMaxMint = 3;
mapping(address => bool) private _allowList;
mapping(address => uint256) private _allowListClaimed;
event AssetMinted(uint256 tokenId, address sender);
event SaleActivation(bool isActive);
constructor(string memory baseURI) ERC721("Crop Clash", "CROP") {
}
modifier saleIsOpen {
}
modifier onlyAuthorized() {
}
function setMaximumAllowedTokens(uint256 _count) public onlyAuthorized {
}
function setActive(bool val) public onlyAuthorized {
}
function setIsAllowListActive(bool _isAllowListActive) external onlyAuthorized {
}
function setAllowListMaxMint(uint256 maxMint) external onlyAuthorized {
}
function addToAllowList(address[] calldata addresses) external onlyAuthorized {
}
function checkIfOnAllowList(address addr) external view returns (bool) {
}
function removeFromAllowList(address[] calldata addresses) external onlyAuthorized {
}
function allowListClaimedBy(address owner) external view returns (uint256){
}
function setReserveAtATime(uint256 val) public onlyAuthorized {
}
function setMaxReserve(uint256 val) public onlyAuthorized {
}
function setPrice(uint256 _price) public onlyAuthorized {
}
function setBaseURI(string memory baseURI) public onlyAuthorized {
}
function getMaximumAllowedTokens() public view onlyAuthorized returns (uint256) {
}
function getPrice() external view returns (uint256) {
}
function getReserveAtATime() external view returns (uint256) {
}
function getTotalSupply() external view returns (uint256) {
}
function getContractOwner() public view returns (address) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function reserveNft() public onlyAuthorized {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
}
function preSaleMint(uint256 _count) public payable saleIsOpen {
require(isAllowListActive, 'Allow List is not active');
require(_allowList[msg.sender], 'You are not on the Allow List');
require(<FILL_ME>)
require(_count <= allowListMaxMint, 'Cannot purchase this many tokens');
require(_allowListClaimed[msg.sender] + _count <= allowListMaxMint, 'Purchase exceeds max allowed');
require(msg.value >= basePrice * _count, 'Insuffient ETH amount sent.');
for (uint256 i = 0; i < _count; i++) {
_allowListClaimed[msg.sender] += 1;
emit AssetMinted(totalSupply(), msg.sender);
_safeMint(msg.sender, totalSupply());
}
}
function walletOfOwner(address _owner) external view returns(uint256[] memory) {
}
function withdraw() external onlyAuthorized {
}
}
| totalSupply()<MAX_MINTSUPPLY,'All tokens have been minted' | 320,350 | totalSupply()<MAX_MINTSUPPLY |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract OwnerHelper
{
address public owner;
address public manager;
event ChangeOwner(address indexed _from, address indexed _to);
event ChangeManager(address indexed _from, address indexed _to);
modifier onlyOwner
{
}
modifier onlyManagerAndOwner
{
}
constructor()
{
}
function transferOwnership(address _to) onlyOwner public
{
}
function transferManager(address _to) onlyOwner public
{
}
}
abstract contract ERC20Interface
{
event Transfer( address indexed _from, address indexed _to, uint _value);
event Approval( address indexed _owner, address indexed _spender, uint _value);
function totalSupply() view virtual public returns (uint _supply);
function balanceOf( address _who ) virtual public view returns (uint _value);
function transfer( address _to, uint _value) virtual public returns (bool _success);
function approve( address _spender, uint _value ) virtual public returns (bool _success);
function allowance( address _owner, address _spender ) virtual public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) virtual public returns (bool _success);
}
contract ARTIC is ERC20Interface, OwnerHelper
{
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
// Total 100,000,000
uint constant public maxTotalSupply = 100000000 * E18;
// Sale 10,000,000 (10%)
uint constant public maxSaleSupply = 10000000 * E18;
// Marketing 25,000,000 (25%)
uint constant public maxMktSupply = 25000000 * E18;
// Development 22,000,000 (22%)
uint constant public maxDevSupply = 22000000 * E18;
// EcoSystem 20,000,000 (20%)
uint constant public maxEcoSupply = 20000000 * E18;
// Legal & Compliance 5,000,000 (5%)
uint constant public maxLegalComplianceSupply = 5000000 * E18;
// Team 5,000,000 (5%)
uint constant public maxTeamSupply = 5000000 * E18;
// Advisors 3,000,000 (3%)
uint constant public maxAdvisorSupply = 3000000 * E18;
// Reserve 10,000,000 (10%)
uint constant public maxReserveSupply = 10000000 * E18;
// Lock
uint constant public teamVestingSupply = 500000 * E18;
uint constant public teamVestingLockDate = 12 * month;
uint constant public teamVestingTime = 10;
uint constant public advisorVestingSupply = 750000 * E18;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedSale;
uint public tokenIssuedMkt;
uint public tokenIssuedDev;
uint public tokenIssuedEco;
uint public tokenIssuedLegalCompliance;
uint public tokenIssuedTeam;
uint public tokenIssuedAdv;
uint public tokenIssuedRsv;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
mapping (uint => uint) public tmVestingTimer;
mapping (uint => uint) public tmVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event SaleIssue(address indexed _to, uint _tokens);
event DevIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event LegalComplianceIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event TeamIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor()
{
}
function totalSupply() view override public returns (uint)
{
}
function balanceOf(address _who) view override public returns (uint)
{
}
function transfer(address _to, uint _value) override public returns (bool)
{
require(<FILL_ME>)
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender] - _value;
balances[_to] = balances[_to] + _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint _value) override public returns (bool)
{
}
function allowance(address _owner, address _spender) view override public returns (uint)
{
}
function transferFrom(address _from, address _to, uint _value) override public returns (bool)
{
}
function saleIssue(address _to) onlyOwner public
{
}
function devIssue(address _to) onlyOwner public
{
}
function ecoIssue(address _to) onlyOwner public
{
}
function mktIssue(address _to) onlyOwner public
{
}
function legalComplianceIssue(address _to) onlyOwner public
{
}
function rsvIssue(address _to) onlyOwner public
{
}
function teamIssue(address _to, uint _time /* 몇 번째 지급인지 */) onlyOwner public
{
}
function advisorIssue(address _to, uint _time) onlyOwner public
{
}
function isTransferable() private view returns (bool)
{
}
function setTokenUnlock() onlyManagerAndOwner public
{
}
function setTokenLock() onlyManagerAndOwner public
{
}
function endSale() onlyOwner public
{
}
function burnToken(uint _value) onlyManagerAndOwner public
{
}
function close() onlyOwner public
{
}
}
| isTransferable()==true | 320,491 | isTransferable()==true |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract OwnerHelper
{
address public owner;
address public manager;
event ChangeOwner(address indexed _from, address indexed _to);
event ChangeManager(address indexed _from, address indexed _to);
modifier onlyOwner
{
}
modifier onlyManagerAndOwner
{
}
constructor()
{
}
function transferOwnership(address _to) onlyOwner public
{
}
function transferManager(address _to) onlyOwner public
{
}
}
abstract contract ERC20Interface
{
event Transfer( address indexed _from, address indexed _to, uint _value);
event Approval( address indexed _owner, address indexed _spender, uint _value);
function totalSupply() view virtual public returns (uint _supply);
function balanceOf( address _who ) virtual public view returns (uint _value);
function transfer( address _to, uint _value) virtual public returns (bool _success);
function approve( address _spender, uint _value ) virtual public returns (bool _success);
function allowance( address _owner, address _spender ) virtual public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) virtual public returns (bool _success);
}
contract ARTIC is ERC20Interface, OwnerHelper
{
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
// Total 100,000,000
uint constant public maxTotalSupply = 100000000 * E18;
// Sale 10,000,000 (10%)
uint constant public maxSaleSupply = 10000000 * E18;
// Marketing 25,000,000 (25%)
uint constant public maxMktSupply = 25000000 * E18;
// Development 22,000,000 (22%)
uint constant public maxDevSupply = 22000000 * E18;
// EcoSystem 20,000,000 (20%)
uint constant public maxEcoSupply = 20000000 * E18;
// Legal & Compliance 5,000,000 (5%)
uint constant public maxLegalComplianceSupply = 5000000 * E18;
// Team 5,000,000 (5%)
uint constant public maxTeamSupply = 5000000 * E18;
// Advisors 3,000,000 (3%)
uint constant public maxAdvisorSupply = 3000000 * E18;
// Reserve 10,000,000 (10%)
uint constant public maxReserveSupply = 10000000 * E18;
// Lock
uint constant public teamVestingSupply = 500000 * E18;
uint constant public teamVestingLockDate = 12 * month;
uint constant public teamVestingTime = 10;
uint constant public advisorVestingSupply = 750000 * E18;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedSale;
uint public tokenIssuedMkt;
uint public tokenIssuedDev;
uint public tokenIssuedEco;
uint public tokenIssuedLegalCompliance;
uint public tokenIssuedTeam;
uint public tokenIssuedAdv;
uint public tokenIssuedRsv;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
mapping (uint => uint) public tmVestingTimer;
mapping (uint => uint) public tmVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event SaleIssue(address indexed _to, uint _tokens);
event DevIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event LegalComplianceIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event TeamIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor()
{
}
function totalSupply() view override public returns (uint)
{
}
function balanceOf(address _who) view override public returns (uint)
{
}
function transfer(address _to, uint _value) override public returns (bool)
{
}
function approve(address _spender, uint _value) override public returns (bool)
{
}
function allowance(address _owner, address _spender) view override public returns (uint)
{
}
function transferFrom(address _from, address _to, uint _value) override public returns (bool)
{
require(isTransferable() == true);
require(balances[_from] >= _value);
require(<FILL_ME>)
approvals[_from][msg.sender] = approvals[_from][msg.sender] - _value;
balances[_from] = balances[_from] - _value;
balances[_to] = balances[_to] + _value;
emit Transfer(_from, _to, _value);
return true;
}
function saleIssue(address _to) onlyOwner public
{
}
function devIssue(address _to) onlyOwner public
{
}
function ecoIssue(address _to) onlyOwner public
{
}
function mktIssue(address _to) onlyOwner public
{
}
function legalComplianceIssue(address _to) onlyOwner public
{
}
function rsvIssue(address _to) onlyOwner public
{
}
function teamIssue(address _to, uint _time /* 몇 번째 지급인지 */) onlyOwner public
{
}
function advisorIssue(address _to, uint _time) onlyOwner public
{
}
function isTransferable() private view returns (bool)
{
}
function setTokenUnlock() onlyManagerAndOwner public
{
}
function setTokenLock() onlyManagerAndOwner public
{
}
function endSale() onlyOwner public
{
}
function burnToken(uint _value) onlyManagerAndOwner public
{
}
function close() onlyOwner public
{
}
}
| approvals[_from][msg.sender]>=_value | 320,491 | approvals[_from][msg.sender]>=_value |
"RebalancingSetIssuance.validateWETHIsAComponentOfSet: Components must contain weth" | /*
Copyright 2019 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
/**
* @title RebalancingSetIssuance
* @author Set Protocol
*
* The RebalancingSetIssuance contains utility functions used in rebalancing SetToken
* issuance
*/
contract RebalancingSetIssuance is
ModuleCoreState
{
using SafeMath for uint256;
using AddressArrayUtils for address[];
// ============ Internal ============
/**
* Validates that wrapped Ether is a component of the SetToken
*
* @param _setAddress Address of the SetToken
* @param _wrappedEtherAddress Address of wrapped Ether
*/
function validateWETHIsAComponentOfSet(
address _setAddress,
address _wrappedEtherAddress
)
internal
view
{
require(<FILL_ME>)
}
/**
* Validates that the passed in address is tracked by Core and that the quantity
* is a multiple of the natural unit
*
* @param _rebalancingSetAddress Address of the rebalancing SetToken to issue/redeem
* @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken
*/
function validateRebalancingSetIssuance(
address _rebalancingSetAddress,
uint256 _rebalancingSetQuantity
)
internal
view
{
}
/**
* Given a rebalancing SetToken and a desired issue quantity, calculates the
* minimum issuable quantity of the base SetToken. If the calculated quantity is initially
* not a multiple of the base SetToken's natural unit, the quantity is rounded up
* to the next base set natural unit.
*
* @param _rebalancingSetAddress Address of the rebalancing SetToken to issue
* @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken
* @return requiredBaseSetQuantity The quantity of base SetToken to issue
*/
function getBaseSetIssuanceRequiredQuantity(
address _rebalancingSetAddress,
uint256 _rebalancingSetQuantity
)
internal
view
returns (uint256)
{
}
/**
* Given a rebalancing SetToken address, retrieve the base SetToken quantity redeem quantity based on the quantity
* held in the Vault. Rounds down to the nearest base SetToken natural unit
*
* @param _baseSetAddress The address of the base SetToken
* @return baseSetRedeemQuantity The quantity of base SetToken to redeem
*/
function getBaseSetRedeemQuantity(
address _baseSetAddress
)
internal
view
returns (uint256)
{
}
/**
* Checks the base SetToken balances in the Vault and on the contract.
* Sends any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _transferProxyAddress The address of the TransferProxy
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user
* or left in the vault
*/
function returnExcessBaseSet(
address _baseSetAddress,
address _transferProxyAddress,
bool _keepChangeInVault
)
internal
{
}
/**
* Checks the base SetToken balances on the contract and sends
* any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _transferProxyAddress The address of the TransferProxy
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user
* or left in the vault
*/
function returnExcessBaseSetFromContract(
address _baseSetAddress,
address _transferProxyAddress,
bool _keepChangeInVault
)
internal
{
}
/**
* Checks the base SetToken balances in the Vault and sends
* any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user
* or left in the vault
*/
function returnExcessBaseSetInVault(
address _baseSetAddress,
bool _keepChangeInVault
)
internal
{
}
}
| ISetToken(_setAddress).tokenIsComponent(_wrappedEtherAddress),"RebalancingSetIssuance.validateWETHIsAComponentOfSet: Components must contain weth" | 320,598 | ISetToken(_setAddress).tokenIsComponent(_wrappedEtherAddress) |
"RebalancingSetIssuance.validateRebalancingIssuance: Invalid or disabled SetToken address" | /*
Copyright 2019 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
/**
* @title RebalancingSetIssuance
* @author Set Protocol
*
* The RebalancingSetIssuance contains utility functions used in rebalancing SetToken
* issuance
*/
contract RebalancingSetIssuance is
ModuleCoreState
{
using SafeMath for uint256;
using AddressArrayUtils for address[];
// ============ Internal ============
/**
* Validates that wrapped Ether is a component of the SetToken
*
* @param _setAddress Address of the SetToken
* @param _wrappedEtherAddress Address of wrapped Ether
*/
function validateWETHIsAComponentOfSet(
address _setAddress,
address _wrappedEtherAddress
)
internal
view
{
}
/**
* Validates that the passed in address is tracked by Core and that the quantity
* is a multiple of the natural unit
*
* @param _rebalancingSetAddress Address of the rebalancing SetToken to issue/redeem
* @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken
*/
function validateRebalancingSetIssuance(
address _rebalancingSetAddress,
uint256 _rebalancingSetQuantity
)
internal
view
{
// Expect rebalancing SetToken to be valid and enabled SetToken
require(<FILL_ME>)
// Make sure Issuance quantity is multiple of the rebalancing SetToken natural unit
require(
_rebalancingSetQuantity.mod(ISetToken(_rebalancingSetAddress).naturalUnit()) == 0,
"RebalancingSetIssuance.validateRebalancingIssuance: Quantity must be multiple of natural unit"
);
}
/**
* Given a rebalancing SetToken and a desired issue quantity, calculates the
* minimum issuable quantity of the base SetToken. If the calculated quantity is initially
* not a multiple of the base SetToken's natural unit, the quantity is rounded up
* to the next base set natural unit.
*
* @param _rebalancingSetAddress Address of the rebalancing SetToken to issue
* @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken
* @return requiredBaseSetQuantity The quantity of base SetToken to issue
*/
function getBaseSetIssuanceRequiredQuantity(
address _rebalancingSetAddress,
uint256 _rebalancingSetQuantity
)
internal
view
returns (uint256)
{
}
/**
* Given a rebalancing SetToken address, retrieve the base SetToken quantity redeem quantity based on the quantity
* held in the Vault. Rounds down to the nearest base SetToken natural unit
*
* @param _baseSetAddress The address of the base SetToken
* @return baseSetRedeemQuantity The quantity of base SetToken to redeem
*/
function getBaseSetRedeemQuantity(
address _baseSetAddress
)
internal
view
returns (uint256)
{
}
/**
* Checks the base SetToken balances in the Vault and on the contract.
* Sends any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _transferProxyAddress The address of the TransferProxy
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user
* or left in the vault
*/
function returnExcessBaseSet(
address _baseSetAddress,
address _transferProxyAddress,
bool _keepChangeInVault
)
internal
{
}
/**
* Checks the base SetToken balances on the contract and sends
* any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _transferProxyAddress The address of the TransferProxy
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user
* or left in the vault
*/
function returnExcessBaseSetFromContract(
address _baseSetAddress,
address _transferProxyAddress,
bool _keepChangeInVault
)
internal
{
}
/**
* Checks the base SetToken balances in the Vault and sends
* any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user
* or left in the vault
*/
function returnExcessBaseSetInVault(
address _baseSetAddress,
bool _keepChangeInVault
)
internal
{
}
}
| coreInstance.validSets(_rebalancingSetAddress),"RebalancingSetIssuance.validateRebalancingIssuance: Invalid or disabled SetToken address" | 320,598 | coreInstance.validSets(_rebalancingSetAddress) |
"RebalancingSetIssuance.validateRebalancingIssuance: Quantity must be multiple of natural unit" | /*
Copyright 2019 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
/**
* @title RebalancingSetIssuance
* @author Set Protocol
*
* The RebalancingSetIssuance contains utility functions used in rebalancing SetToken
* issuance
*/
contract RebalancingSetIssuance is
ModuleCoreState
{
using SafeMath for uint256;
using AddressArrayUtils for address[];
// ============ Internal ============
/**
* Validates that wrapped Ether is a component of the SetToken
*
* @param _setAddress Address of the SetToken
* @param _wrappedEtherAddress Address of wrapped Ether
*/
function validateWETHIsAComponentOfSet(
address _setAddress,
address _wrappedEtherAddress
)
internal
view
{
}
/**
* Validates that the passed in address is tracked by Core and that the quantity
* is a multiple of the natural unit
*
* @param _rebalancingSetAddress Address of the rebalancing SetToken to issue/redeem
* @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken
*/
function validateRebalancingSetIssuance(
address _rebalancingSetAddress,
uint256 _rebalancingSetQuantity
)
internal
view
{
// Expect rebalancing SetToken to be valid and enabled SetToken
require(
coreInstance.validSets(_rebalancingSetAddress),
"RebalancingSetIssuance.validateRebalancingIssuance: Invalid or disabled SetToken address"
);
// Make sure Issuance quantity is multiple of the rebalancing SetToken natural unit
require(<FILL_ME>)
}
/**
* Given a rebalancing SetToken and a desired issue quantity, calculates the
* minimum issuable quantity of the base SetToken. If the calculated quantity is initially
* not a multiple of the base SetToken's natural unit, the quantity is rounded up
* to the next base set natural unit.
*
* @param _rebalancingSetAddress Address of the rebalancing SetToken to issue
* @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken
* @return requiredBaseSetQuantity The quantity of base SetToken to issue
*/
function getBaseSetIssuanceRequiredQuantity(
address _rebalancingSetAddress,
uint256 _rebalancingSetQuantity
)
internal
view
returns (uint256)
{
}
/**
* Given a rebalancing SetToken address, retrieve the base SetToken quantity redeem quantity based on the quantity
* held in the Vault. Rounds down to the nearest base SetToken natural unit
*
* @param _baseSetAddress The address of the base SetToken
* @return baseSetRedeemQuantity The quantity of base SetToken to redeem
*/
function getBaseSetRedeemQuantity(
address _baseSetAddress
)
internal
view
returns (uint256)
{
}
/**
* Checks the base SetToken balances in the Vault and on the contract.
* Sends any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _transferProxyAddress The address of the TransferProxy
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user
* or left in the vault
*/
function returnExcessBaseSet(
address _baseSetAddress,
address _transferProxyAddress,
bool _keepChangeInVault
)
internal
{
}
/**
* Checks the base SetToken balances on the contract and sends
* any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _transferProxyAddress The address of the TransferProxy
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user
* or left in the vault
*/
function returnExcessBaseSetFromContract(
address _baseSetAddress,
address _transferProxyAddress,
bool _keepChangeInVault
)
internal
{
}
/**
* Checks the base SetToken balances in the Vault and sends
* any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user
* or left in the vault
*/
function returnExcessBaseSetInVault(
address _baseSetAddress,
bool _keepChangeInVault
)
internal
{
}
}
| _rebalancingSetQuantity.mod(ISetToken(_rebalancingSetAddress).naturalUnit())==0,"RebalancingSetIssuance.validateRebalancingIssuance: Quantity must be multiple of natural unit" | 320,598 | _rebalancingSetQuantity.mod(ISetToken(_rebalancingSetAddress).naturalUnit())==0 |
add | /*
Copyright 2019 Set Labs Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
pragma solidity 0.5.7;
/**
* @title RebalancingSetIssuance
* @author Set Protocol
*
* The RebalancingSetIssuance contains utility functions used in rebalancing SetToken
* issuance
*/
contract RebalancingSetIssuance is
ModuleCoreState
{
using SafeMath for uint256;
using AddressArrayUtils for address[];
// ============ Internal ============
/**
* Validates that wrapped Ether is a component of the SetToken
*
* @param _setAddress Address of the SetToken
* @param _wrappedEtherAddress Address of wrapped Ether
*/
function validateWETHIsAComponentOfSet(
address _setAddress,
address _wrappedEtherAddress
)
internal
view
{
}
/**
* Validates that the passed in address is tracked by Core and that the quantity
* is a multiple of the natural unit
*
* @param _rebalancingSetAddress Address of the rebalancing SetToken to issue/redeem
* @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken
*/
function validateRebalancingSetIssuance(
address _rebalancingSetAddress,
uint256 _rebalancingSetQuantity
)
internal
view
{
}
/**
* Given a rebalancing SetToken and a desired issue quantity, calculates the
* minimum issuable quantity of the base SetToken. If the calculated quantity is initially
* not a multiple of the base SetToken's natural unit, the quantity is rounded up
* to the next base set natural unit.
*
* @param _rebalancingSetAddress Address of the rebalancing SetToken to issue
* @param _rebalancingSetQuantity The issuance quantity of rebalancing SetToken
* @return requiredBaseSetQuantity The quantity of base SetToken to issue
*/
function getBaseSetIssuanceRequiredQuantity(
address _rebalancingSetAddress,
uint256 _rebalancingSetQuantity
)
internal
view
returns (uint256)
{
IRebalancingSetTokenV2 rebalancingSet = IRebalancingSetTokenV2(_rebalancingSetAddress);
uint256 unitShares = rebalancingSet.unitShares();
uint256 naturalUnit = rebalancingSet.naturalUnit();
uint256 requiredBaseSetQuantity = _rebalancingSetQuantity.div(naturalUnit).mul(unitShares);
address baseSet = rebalancingSet.currentSet();
uint256 baseSetNaturalUnit = ISetToken(baseSet).naturalUnit();
// If there is a mismatch between the required quantity and the base SetToken natural unit,
// round up to the next base SetToken natural unit if required.
uint256 roundDownQuantity = requiredBaseSetQuantity.mod(baseSetNaturalUnit);
if (roundDownQuantity > 0) {
require(<FILL_ME>)
}
return requiredBaseSetQuantity;
}
/**
* Given a rebalancing SetToken address, retrieve the base SetToken quantity redeem quantity based on the quantity
* held in the Vault. Rounds down to the nearest base SetToken natural unit
*
* @param _baseSetAddress The address of the base SetToken
* @return baseSetRedeemQuantity The quantity of base SetToken to redeem
*/
function getBaseSetRedeemQuantity(
address _baseSetAddress
)
internal
view
returns (uint256)
{
}
/**
* Checks the base SetToken balances in the Vault and on the contract.
* Sends any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _transferProxyAddress The address of the TransferProxy
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transferred to the user
* or left in the vault
*/
function returnExcessBaseSet(
address _baseSetAddress,
address _transferProxyAddress,
bool _keepChangeInVault
)
internal
{
}
/**
* Checks the base SetToken balances on the contract and sends
* any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _transferProxyAddress The address of the TransferProxy
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user
* or left in the vault
*/
function returnExcessBaseSetFromContract(
address _baseSetAddress,
address _transferProxyAddress,
bool _keepChangeInVault
)
internal
{
}
/**
* Checks the base SetToken balances in the Vault and sends
* any positive quantity to the user directly or into the Vault
* depending on the keepChangeInVault flag.
*
* @param _baseSetAddress The address of the base SetToken
* @param _keepChangeInVault Boolean signifying whether excess base SetToken is transfered to the user
* or left in the vault
*/
function returnExcessBaseSetInVault(
address _baseSetAddress,
bool _keepChangeInVault
)
internal
{
}
}
| BaseSetQuantity=requiredBaseSetQuantity.sub(roundDownQuantity).add(baseSetNaturalUnit | 320,598 | requiredBaseSetQuantity.sub(roundDownQuantity) |
"AlreadyClaimed" | pragma solidity >=0.8.0;
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
/*///////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint8 public immutable decimals;
/*///////////////////////////////////////////////////////////////
ERC20 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
/*///////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
bytes32 public constant PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
/*///////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
/*///////////////////////////////////////////////////////////////
ERC20 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
/*///////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
}
/*///////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 amount) internal virtual {
}
function _burn(address from, uint256 amount) internal virtual {
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/MerkleProof.sol)
pragma solidity ^0.8.0;
/**
* @dev These functions deal with verification of Merkle Trees proofs.
*
* The proofs can be generated using the JavaScript library
* https://github.com/miguelmota/merkletreejs[merkletreejs].
* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
*
* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
*/
library MerkleProof {
/**
* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
* defined by `root`. For this, a `proof` must be provided, containing
* sibling hashes on the branch from the leaf to the root of the tree. Each
* pair of leaves and each pair of pre-images are assumed to be sorted.
*/
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
}
/**
* @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
* hash matches the root of the tree. When processing the proof, the pairs
* of leafs & pre-images are assumed to be sorted.
*
* _Available since v4.4._
*/
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
}
}
contract MerkleClaimERC20 is ERC20 {
/// for airdrop
uint256 public constant AMOUNT_AIRDROP = 1.55455e11 ether;
uint256 public constant MAX_SUPPLY = AMOUNT_AIRDROP * 2;
/// for DAO
uint256 public constant AMOUNT_DAO = MAX_SUPPLY/ 100 * 20;
address public constant ADDR_DAO = 0x1E09eEF8f405C7edCa46b08B236854EC4A5ae213;
/// for liquidity incentives
uint256 public constant AMOUNT_LP = MAX_SUPPLY / 100 * 25;
address public constant ADDR_LP = 0xf4Ed582037f5B1218d2ec65b7F2cbEDad7eF8977;
/// for team
uint256 public constant AMOUNT_TEAM = MAX_SUPPLY / 100 * 5;
address public constant ADDR_TEAM = 0x944BbC959003196C10C0C989804DF27aE388300C;
/// ============ Immutable storage ============
/// @notice ERC20-claimee inclusion root
bytes32 public immutable merkleRoot;
/// ============ Mutable storage ============
/// @notice Mapping of addresses who have claimed tokens
mapping(address => bool) public hasClaimed;
/// ============ Constructor ============
/// @notice Creates a new MerkleClaimERC20 contract
/// @param _name of token
/// @param _symbol of token
/// @param _decimals of token
/// @param _merkleRoot of claimees
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals,
bytes32 _merkleRoot
) ERC20(_name, _symbol, _decimals) {
}
/// ============ Events ============
/// @notice Emitted after a successful token claim
/// @param to recipient of claim
/// @param amount of tokens claimed
event Claim(address indexed to, uint256 amount);
/// ============ Functions ============
/// @notice Allows claiming tokens if address is part of merkle tree
/// @param to address of claimee
/// @param amount of tokens owed to claimee
/// @param proof merkle proof to prove address and amount are in tree
function claim(address to, uint256 amount, bytes32[] calldata proof) external {
// Throw if address has already claimed tokens
require(<FILL_ME>)
// Verify merkle proof, or revert if not in tree
bytes32 leaf = keccak256(abi.encodePacked(to, amount));
bool isValidLeaf = MerkleProof.verify(proof, merkleRoot, leaf);
require(isValidLeaf, "NotInMerkle");
// Set address to claimed
hasClaimed[to] = true;
// Mint tokens to address
_mint(to, amount);
// Emit claim event
emit Claim(to, amount);
}
}
| !hasClaimed[to],"AlreadyClaimed" | 320,724 | !hasClaimed[to] |
null | pragma solidity ^0.4.19;
contract Love {
mapping (address => address) private propose;
mapping (address => address) private partner;
mapping (uint256 => string[]) private partnerMessages;
mapping (uint256 => bool) private isHiddenMessages;
uint public proposeCount;
uint public partnerCount;
event Propose(address indexed from, address indexed to);
event CancelPropose(address indexed from, address indexed to);
event Partner(address indexed from, address indexed to);
event Farewell(address indexed from, address indexed to);
event Message(address indexed addressOne, address indexed addressTwo, string message, uint index);
event HiddenMessages(address indexed addressOne, address indexed addressTwo, bool flag);
function proposeTo(address to) public {
require(to != address(0));
require(msg.sender != to);
require(<FILL_ME>)
address alreadyPropose = propose[to];
if (alreadyPropose == msg.sender) {
propose[to] = address(0);
if (propose[msg.sender] != address(0)) {
propose[msg.sender] = address(0);
proposeCount -= 2;
} else {
proposeCount--;
}
address selfPartner = partner[msg.sender];
if (selfPartner != address(0)) {
if (partner[selfPartner] == msg.sender) {
partner[selfPartner] = address(0);
partnerCount--;
Farewell(msg.sender, selfPartner);
}
}
partner[msg.sender] = to;
address targetPartner = partner[to];
if (targetPartner != address(0)) {
if (partner[targetPartner] == to) {
partner[targetPartner] = address(0);
partnerCount--;
Farewell(to, targetPartner);
}
}
partner[to] = msg.sender;
partnerCount++;
Partner(msg.sender, to);
} else {
if (propose[msg.sender] == address(0)) {
proposeCount++;
}
propose[msg.sender] = to;
Propose(msg.sender, to);
}
}
function cancelProposeTo() public {
}
function addMessage(string message) public {
}
function farewellTo(address to) public {
}
function isPartner(address a, address b) public view returns (bool) {
}
function getPropose(address a) public view returns (address) {
}
function getPartner(address a) public view returns (address) {
}
function getPartnerMessage(address a, address b, uint index) public view returns (string) {
}
function partnerMessagesCount(address a, address b) public view returns (uint) {
}
function getOwnPartnerMessage(uint index) public view returns (string) {
}
function craetePartnerBytes(address a, address b) private pure returns(bytes) {
}
function setIsHiddenMessages(bool flag) public {
}
}
| partner[msg.sender]!=to | 320,772 | partner[msg.sender]!=to |
null | pragma solidity ^0.4.19;
contract Love {
mapping (address => address) private propose;
mapping (address => address) private partner;
mapping (uint256 => string[]) private partnerMessages;
mapping (uint256 => bool) private isHiddenMessages;
uint public proposeCount;
uint public partnerCount;
event Propose(address indexed from, address indexed to);
event CancelPropose(address indexed from, address indexed to);
event Partner(address indexed from, address indexed to);
event Farewell(address indexed from, address indexed to);
event Message(address indexed addressOne, address indexed addressTwo, string message, uint index);
event HiddenMessages(address indexed addressOne, address indexed addressTwo, bool flag);
function proposeTo(address to) public {
}
function cancelProposeTo() public {
}
function addMessage(string message) public {
address target = partner[msg.sender];
require(<FILL_ME>)
uint index = partnerMessages[uint256(keccak256(craetePartnerBytes(msg.sender, target)))].push(message) - 1;
Message(msg.sender, target, message, index);
}
function farewellTo(address to) public {
}
function isPartner(address a, address b) public view returns (bool) {
}
function getPropose(address a) public view returns (address) {
}
function getPartner(address a) public view returns (address) {
}
function getPartnerMessage(address a, address b, uint index) public view returns (string) {
}
function partnerMessagesCount(address a, address b) public view returns (uint) {
}
function getOwnPartnerMessage(uint index) public view returns (string) {
}
function craetePartnerBytes(address a, address b) private pure returns(bytes) {
}
function setIsHiddenMessages(bool flag) public {
}
}
| isPartner(msg.sender,target)==true | 320,772 | isPartner(msg.sender,target)==true |
null | pragma solidity ^0.4.19;
contract Love {
mapping (address => address) private propose;
mapping (address => address) private partner;
mapping (uint256 => string[]) private partnerMessages;
mapping (uint256 => bool) private isHiddenMessages;
uint public proposeCount;
uint public partnerCount;
event Propose(address indexed from, address indexed to);
event CancelPropose(address indexed from, address indexed to);
event Partner(address indexed from, address indexed to);
event Farewell(address indexed from, address indexed to);
event Message(address indexed addressOne, address indexed addressTwo, string message, uint index);
event HiddenMessages(address indexed addressOne, address indexed addressTwo, bool flag);
function proposeTo(address to) public {
}
function cancelProposeTo() public {
}
function addMessage(string message) public {
}
function farewellTo(address to) public {
require(<FILL_ME>)
require(partner[to] == msg.sender);
partner[msg.sender] = address(0);
partner[to] = address(0);
partnerCount--;
Farewell(msg.sender, to);
}
function isPartner(address a, address b) public view returns (bool) {
}
function getPropose(address a) public view returns (address) {
}
function getPartner(address a) public view returns (address) {
}
function getPartnerMessage(address a, address b, uint index) public view returns (string) {
}
function partnerMessagesCount(address a, address b) public view returns (uint) {
}
function getOwnPartnerMessage(uint index) public view returns (string) {
}
function craetePartnerBytes(address a, address b) private pure returns(bytes) {
}
function setIsHiddenMessages(bool flag) public {
}
}
| partner[msg.sender]==to | 320,772 | partner[msg.sender]==to |
null | pragma solidity ^0.4.19;
contract Love {
mapping (address => address) private propose;
mapping (address => address) private partner;
mapping (uint256 => string[]) private partnerMessages;
mapping (uint256 => bool) private isHiddenMessages;
uint public proposeCount;
uint public partnerCount;
event Propose(address indexed from, address indexed to);
event CancelPropose(address indexed from, address indexed to);
event Partner(address indexed from, address indexed to);
event Farewell(address indexed from, address indexed to);
event Message(address indexed addressOne, address indexed addressTwo, string message, uint index);
event HiddenMessages(address indexed addressOne, address indexed addressTwo, bool flag);
function proposeTo(address to) public {
}
function cancelProposeTo() public {
}
function addMessage(string message) public {
}
function farewellTo(address to) public {
require(partner[msg.sender] == to);
require(<FILL_ME>)
partner[msg.sender] = address(0);
partner[to] = address(0);
partnerCount--;
Farewell(msg.sender, to);
}
function isPartner(address a, address b) public view returns (bool) {
}
function getPropose(address a) public view returns (address) {
}
function getPartner(address a) public view returns (address) {
}
function getPartnerMessage(address a, address b, uint index) public view returns (string) {
}
function partnerMessagesCount(address a, address b) public view returns (uint) {
}
function getOwnPartnerMessage(uint index) public view returns (string) {
}
function craetePartnerBytes(address a, address b) private pure returns(bytes) {
}
function setIsHiddenMessages(bool flag) public {
}
}
| partner[to]==msg.sender | 320,772 | partner[to]==msg.sender |
null | pragma solidity ^0.4.19;
contract Love {
mapping (address => address) private propose;
mapping (address => address) private partner;
mapping (uint256 => string[]) private partnerMessages;
mapping (uint256 => bool) private isHiddenMessages;
uint public proposeCount;
uint public partnerCount;
event Propose(address indexed from, address indexed to);
event CancelPropose(address indexed from, address indexed to);
event Partner(address indexed from, address indexed to);
event Farewell(address indexed from, address indexed to);
event Message(address indexed addressOne, address indexed addressTwo, string message, uint index);
event HiddenMessages(address indexed addressOne, address indexed addressTwo, bool flag);
function proposeTo(address to) public {
}
function cancelProposeTo() public {
}
function addMessage(string message) public {
}
function farewellTo(address to) public {
}
function isPartner(address a, address b) public view returns (bool) {
}
function getPropose(address a) public view returns (address) {
}
function getPartner(address a) public view returns (address) {
}
function getPartnerMessage(address a, address b, uint index) public view returns (string) {
require(<FILL_ME>)
uint256 key = uint256(keccak256(craetePartnerBytes(a, b)));
if (isHiddenMessages[key] == true) {
require((msg.sender == a) || (msg.sender == b));
}
uint count = partnerMessages[key].length;
require(index < count);
return partnerMessages[key][index];
}
function partnerMessagesCount(address a, address b) public view returns (uint) {
}
function getOwnPartnerMessage(uint index) public view returns (string) {
}
function craetePartnerBytes(address a, address b) private pure returns(bytes) {
}
function setIsHiddenMessages(bool flag) public {
}
}
| isPartner(a,b)==true | 320,772 | isPartner(a,b)==true |
null | pragma solidity ^0.4.19;
contract Love {
mapping (address => address) private propose;
mapping (address => address) private partner;
mapping (uint256 => string[]) private partnerMessages;
mapping (uint256 => bool) private isHiddenMessages;
uint public proposeCount;
uint public partnerCount;
event Propose(address indexed from, address indexed to);
event CancelPropose(address indexed from, address indexed to);
event Partner(address indexed from, address indexed to);
event Farewell(address indexed from, address indexed to);
event Message(address indexed addressOne, address indexed addressTwo, string message, uint index);
event HiddenMessages(address indexed addressOne, address indexed addressTwo, bool flag);
function proposeTo(address to) public {
}
function cancelProposeTo() public {
}
function addMessage(string message) public {
}
function farewellTo(address to) public {
}
function isPartner(address a, address b) public view returns (bool) {
}
function getPropose(address a) public view returns (address) {
}
function getPartner(address a) public view returns (address) {
}
function getPartnerMessage(address a, address b, uint index) public view returns (string) {
require(isPartner(a, b) == true);
uint256 key = uint256(keccak256(craetePartnerBytes(a, b)));
if (isHiddenMessages[key] == true) {
require(<FILL_ME>)
}
uint count = partnerMessages[key].length;
require(index < count);
return partnerMessages[key][index];
}
function partnerMessagesCount(address a, address b) public view returns (uint) {
}
function getOwnPartnerMessage(uint index) public view returns (string) {
}
function craetePartnerBytes(address a, address b) private pure returns(bytes) {
}
function setIsHiddenMessages(bool flag) public {
}
}
| (msg.sender==a)||(msg.sender==b) | 320,772 | (msg.sender==a)||(msg.sender==b) |
null | pragma solidity ^0.4.19;
contract Love {
mapping (address => address) private propose;
mapping (address => address) private partner;
mapping (uint256 => string[]) private partnerMessages;
mapping (uint256 => bool) private isHiddenMessages;
uint public proposeCount;
uint public partnerCount;
event Propose(address indexed from, address indexed to);
event CancelPropose(address indexed from, address indexed to);
event Partner(address indexed from, address indexed to);
event Farewell(address indexed from, address indexed to);
event Message(address indexed addressOne, address indexed addressTwo, string message, uint index);
event HiddenMessages(address indexed addressOne, address indexed addressTwo, bool flag);
function proposeTo(address to) public {
}
function cancelProposeTo() public {
}
function addMessage(string message) public {
}
function farewellTo(address to) public {
}
function isPartner(address a, address b) public view returns (bool) {
}
function getPropose(address a) public view returns (address) {
}
function getPartner(address a) public view returns (address) {
}
function getPartnerMessage(address a, address b, uint index) public view returns (string) {
}
function partnerMessagesCount(address a, address b) public view returns (uint) {
}
function getOwnPartnerMessage(uint index) public view returns (string) {
}
function craetePartnerBytes(address a, address b) private pure returns(bytes) {
}
function setIsHiddenMessages(bool flag) public {
require(<FILL_ME>)
uint256 key = uint256(keccak256(craetePartnerBytes(msg.sender, partner[msg.sender])));
isHiddenMessages[key] = flag;
HiddenMessages(msg.sender, partner[msg.sender], flag);
}
}
| isPartner(msg.sender,partner[msg.sender])==true | 320,772 | isPartner(msg.sender,partner[msg.sender])==true |
"Not enough free mints remaining" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
//Thanks to WKM and Pixel Doods for the open source contract.
contract DoggiesNFT is Ownable, ERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenSupply;
uint256 public constant MAX_TOKENS = 10001;
uint256 public constant MINT_TRANSACTION_LIMIT = 9;
uint256 public tokenPrice = 0.035 ether;
uint256 public freeMints = 1001;
bool public saleIsActive;
string _baseTokenURI;
address _proxyRegistryAddress;
constructor(address proxyRegistryAddress) ERC721("Doggies NFT", "DGGY") {
}
function freeMint(uint256 amount) external {
require(saleIsActive, "Sale is not active");
require(amount < MINT_TRANSACTION_LIMIT, "Mint amount too large");
uint256 supply = _tokenSupply.current();
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
_tokenSupply.increment();
_safeMint(msg.sender, supply + i);
}
}
function publicMint(uint256 amount) external payable {
}
function reserveTokens(address to, uint256 amount) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setProxyRegistryAddress(address proxyRegistryAddress)
external
onlyOwner
{
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
receive() external payable {}
function withdraw() external onlyOwner {
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| supply+amount<freeMints,"Not enough free mints remaining" | 320,786 | supply+amount<freeMints |
"Not enough tokens remaining" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
//Thanks to WKM and Pixel Doods for the open source contract.
contract DoggiesNFT is Ownable, ERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenSupply;
uint256 public constant MAX_TOKENS = 10001;
uint256 public constant MINT_TRANSACTION_LIMIT = 9;
uint256 public tokenPrice = 0.035 ether;
uint256 public freeMints = 1001;
bool public saleIsActive;
string _baseTokenURI;
address _proxyRegistryAddress;
constructor(address proxyRegistryAddress) ERC721("Doggies NFT", "DGGY") {
}
function freeMint(uint256 amount) external {
}
function publicMint(uint256 amount) external payable {
require(saleIsActive, "Sale is not active");
require(amount < MINT_TRANSACTION_LIMIT, "Mint amount too large");
uint256 supply = _tokenSupply.current();
require(<FILL_ME>)
require(tokenPrice * amount <= msg.value, "Not enough ether sent");
for (uint256 i = 0; i < amount; i++) {
_tokenSupply.increment();
_safeMint(msg.sender, supply + i);
}
}
function reserveTokens(address to, uint256 amount) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setProxyRegistryAddress(address proxyRegistryAddress)
external
onlyOwner
{
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
receive() external payable {}
function withdraw() external onlyOwner {
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| supply+amount<MAX_TOKENS,"Not enough tokens remaining" | 320,786 | supply+amount<MAX_TOKENS |
"Not enough ether sent" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
//Thanks to WKM and Pixel Doods for the open source contract.
contract DoggiesNFT is Ownable, ERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenSupply;
uint256 public constant MAX_TOKENS = 10001;
uint256 public constant MINT_TRANSACTION_LIMIT = 9;
uint256 public tokenPrice = 0.035 ether;
uint256 public freeMints = 1001;
bool public saleIsActive;
string _baseTokenURI;
address _proxyRegistryAddress;
constructor(address proxyRegistryAddress) ERC721("Doggies NFT", "DGGY") {
}
function freeMint(uint256 amount) external {
}
function publicMint(uint256 amount) external payable {
require(saleIsActive, "Sale is not active");
require(amount < MINT_TRANSACTION_LIMIT, "Mint amount too large");
uint256 supply = _tokenSupply.current();
require(supply + amount < MAX_TOKENS, "Not enough tokens remaining");
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
_tokenSupply.increment();
_safeMint(msg.sender, supply + i);
}
}
function reserveTokens(address to, uint256 amount) external onlyOwner {
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function flipSaleState() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setProxyRegistryAddress(address proxyRegistryAddress)
external
onlyOwner
{
}
function isApprovedForAll(address owner, address operator)
public
view
override
returns (bool)
{
}
receive() external payable {}
function withdraw() external onlyOwner {
}
}
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
| tokenPrice*amount<=msg.value,"Not enough ether sent" | 320,786 | tokenPrice*amount<=msg.value |
"ETH sent is incorrect." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract WLNFT_LaunchPass is ERC721A, Ownable {
bool public saleIsActive = false;
uint256 public preSalePrice = 1000000000000000000; // for compatibility with WenMint hosted form
uint256 public pubSalePrice = 1000000000000000000;
uint256 public maxPerWallet = 1; // for compatibility with WenMint hosted form
uint256 public maxPerTransaction = 1;
uint256 public maxSupply = 10000;
string _baseTokenURI;
address proxyRegistryAddress;
constructor(address _proxyRegistryAddress) ERC721A("WhitelistNFT LaunchPass", "WxLAUNCH", 100) {
}
function baseTokenURI() virtual public view returns (string memory) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function setBaseTokenURI(string memory _uri) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) external onlyOwner {
}
function setPubSalePrice(uint256 _price) external onlyOwner {
}
function setMaxPerTransaction(uint256 _maxToMint) external onlyOwner {
}
function flipSaleState() public onlyOwner {
}
function reserve(address _address, uint256 _quantity) public onlyOwner {
}
function mint(uint256 _quantity) public payable {
require(saleIsActive, "Sale is not active.");
require(totalSupply() < maxSupply, "Sold out.");
require(<FILL_ME>)
require(_quantity <= maxPerTransaction, "Exceeds per transaction limit.");
_safeMint(msg.sender, _quantity);
}
function withdraw() external onlyOwner {
}
}
| pubSalePrice*_quantity<=msg.value,"ETH sent is incorrect." | 320,863 | pubSalePrice*_quantity<=msg.value |
"Quantity Exceeds Tokens Available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
import "@openzeppelin/[email protected]/access/Ownable.sol";
contract SANTAFORCE is ERC721, Ownable {
using Strings for uint256;
bool public isSale = false;
bool public isMintRef = false;
uint256 public currentToken = 0;
uint256 public maxSupply = 10000;
uint256 public price = 0.08 ether;
string public metaUri = "https://santaforce.io/tokens/";
constructor() ERC721("Santa Force", "SantaNFT") {}
// Mint Functions
function mint(uint256 quantity) public payable {
require(isSale, "Public Sale is Not Active");
require(<FILL_ME>)
uint256 pricenow = price;
if (quantity >= 15) {
pricenow = 0.06 ether;
} else if (quantity >= 8) {
pricenow = 0.07 ether;
}
require((pricenow * quantity) <= msg.value, "Ether Amount Sent Is Incorrect");
for (uint256 i = 0; i < quantity; i++) {
_safeMint(msg.sender, currentToken);
currentToken = currentToken + 1;
}
}
function mintRef(uint256 quantity, address ref) public payable {
}
function ownerMint(address[] memory addresses) external onlyOwner {
}
// Token URL and Supply Functions - Public
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
// Setter Functions - onlyOwner
function triggerSale() public onlyOwner {
}
function triggerRef() public onlyOwner {
}
function setMetaURI(string memory newURI) external onlyOwner {
}
// Withdraw Function - onlyOwner
function withdraw() external onlyOwner {
}
// Internal Functions
function _baseURI() override internal view returns (string memory) {
}
}
| (currentToken+quantity)<=maxSupply,"Quantity Exceeds Tokens Available" | 320,902 | (currentToken+quantity)<=maxSupply |
"Ether Amount Sent Is Incorrect" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
import "@openzeppelin/[email protected]/access/Ownable.sol";
contract SANTAFORCE is ERC721, Ownable {
using Strings for uint256;
bool public isSale = false;
bool public isMintRef = false;
uint256 public currentToken = 0;
uint256 public maxSupply = 10000;
uint256 public price = 0.08 ether;
string public metaUri = "https://santaforce.io/tokens/";
constructor() ERC721("Santa Force", "SantaNFT") {}
// Mint Functions
function mint(uint256 quantity) public payable {
require(isSale, "Public Sale is Not Active");
require((currentToken + quantity) <= maxSupply, "Quantity Exceeds Tokens Available");
uint256 pricenow = price;
if (quantity >= 15) {
pricenow = 0.06 ether;
} else if (quantity >= 8) {
pricenow = 0.07 ether;
}
require(<FILL_ME>)
for (uint256 i = 0; i < quantity; i++) {
_safeMint(msg.sender, currentToken);
currentToken = currentToken + 1;
}
}
function mintRef(uint256 quantity, address ref) public payable {
}
function ownerMint(address[] memory addresses) external onlyOwner {
}
// Token URL and Supply Functions - Public
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
// Setter Functions - onlyOwner
function triggerSale() public onlyOwner {
}
function triggerRef() public onlyOwner {
}
function setMetaURI(string memory newURI) external onlyOwner {
}
// Withdraw Function - onlyOwner
function withdraw() external onlyOwner {
}
// Internal Functions
function _baseURI() override internal view returns (string memory) {
}
}
| (pricenow*quantity)<=msg.value,"Ether Amount Sent Is Incorrect" | 320,902 | (pricenow*quantity)<=msg.value |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
import "@openzeppelin/[email protected]/access/Ownable.sol";
contract SANTAFORCE is ERC721, Ownable {
using Strings for uint256;
bool public isSale = false;
bool public isMintRef = false;
uint256 public currentToken = 0;
uint256 public maxSupply = 10000;
uint256 public price = 0.08 ether;
string public metaUri = "https://santaforce.io/tokens/";
constructor() ERC721("Santa Force", "SantaNFT") {}
// Mint Functions
function mint(uint256 quantity) public payable {
}
function mintRef(uint256 quantity, address ref) public payable {
require(isSale, "Public Sale is Not Active");
require(isMintRef, "Minting with Referral is Not Active");
require((currentToken + quantity) <= maxSupply, "Quantity Exceeds Tokens Available");
uint256 pricenow = price;
if (quantity >= 15) {
pricenow = 0.06 ether;
} else if (quantity >= 8) {
pricenow = 0.07 ether;
}
require((pricenow * quantity) <= msg.value, "Ether Amount Sent Is Incorrect");
for (uint256 i = 0; i < quantity; i++) {
_safeMint(msg.sender, currentToken);
currentToken = currentToken + 1;
}
if (ref != 0x0000000000000000000000000000000000000000) {
require(<FILL_ME>)
}
}
function ownerMint(address[] memory addresses) external onlyOwner {
}
// Token URL and Supply Functions - Public
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
// Setter Functions - onlyOwner
function triggerSale() public onlyOwner {
}
function triggerRef() public onlyOwner {
}
function setMetaURI(string memory newURI) external onlyOwner {
}
// Withdraw Function - onlyOwner
function withdraw() external onlyOwner {
}
// Internal Functions
function _baseURI() override internal view returns (string memory) {
}
}
| payable(ref).send((pricenow*quantity*30/100)) | 320,902 | payable(ref).send((pricenow*quantity*30/100)) |
"Quantity Exceeds Tokens Available" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
import "@openzeppelin/[email protected]/access/Ownable.sol";
contract SANTAFORCE is ERC721, Ownable {
using Strings for uint256;
bool public isSale = false;
bool public isMintRef = false;
uint256 public currentToken = 0;
uint256 public maxSupply = 10000;
uint256 public price = 0.08 ether;
string public metaUri = "https://santaforce.io/tokens/";
constructor() ERC721("Santa Force", "SantaNFT") {}
// Mint Functions
function mint(uint256 quantity) public payable {
}
function mintRef(uint256 quantity, address ref) public payable {
}
function ownerMint(address[] memory addresses) external onlyOwner {
require(<FILL_ME>)
for (uint256 i = 0; i < addresses.length; i++) {
_safeMint(addresses[i], currentToken);
currentToken = currentToken + 1;
}
}
// Token URL and Supply Functions - Public
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
// Setter Functions - onlyOwner
function triggerSale() public onlyOwner {
}
function triggerRef() public onlyOwner {
}
function setMetaURI(string memory newURI) external onlyOwner {
}
// Withdraw Function - onlyOwner
function withdraw() external onlyOwner {
}
// Internal Functions
function _baseURI() override internal view returns (string memory) {
}
}
| (currentToken+addresses.length)<=maxSupply,"Quantity Exceeds Tokens Available" | 320,902 | (currentToken+addresses.length)<=maxSupply |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
import "@openzeppelin/[email protected]/access/Ownable.sol";
contract SANTAFORCE is ERC721, Ownable {
using Strings for uint256;
bool public isSale = false;
bool public isMintRef = false;
uint256 public currentToken = 0;
uint256 public maxSupply = 10000;
uint256 public price = 0.08 ether;
string public metaUri = "https://santaforce.io/tokens/";
constructor() ERC721("Santa Force", "SantaNFT") {}
// Mint Functions
function mint(uint256 quantity) public payable {
}
function mintRef(uint256 quantity, address ref) public payable {
}
function ownerMint(address[] memory addresses) external onlyOwner {
}
// Token URL and Supply Functions - Public
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
// Setter Functions - onlyOwner
function triggerSale() public onlyOwner {
}
function triggerRef() public onlyOwner {
}
function setMetaURI(string memory newURI) external onlyOwner {
}
// Withdraw Function - onlyOwner
function withdraw() external onlyOwner {
uint256 twoPercent = address(this).balance*2/100;
uint256 remaining = address(this).balance*98/100;
require(<FILL_ME>)
require(payable(0x0ECbE30790B6a690D4088B70dCC27664ca530D55).send(remaining));
}
// Internal Functions
function _baseURI() override internal view returns (string memory) {
}
}
| payable(0x4fF30f9e84fCD227f59CE788869aeAF7e4da9915).send(twoPercent) | 320,902 | payable(0x4fF30f9e84fCD227f59CE788869aeAF7e4da9915).send(twoPercent) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/[email protected]/token/ERC721/ERC721.sol";
import "@openzeppelin/[email protected]/access/Ownable.sol";
contract SANTAFORCE is ERC721, Ownable {
using Strings for uint256;
bool public isSale = false;
bool public isMintRef = false;
uint256 public currentToken = 0;
uint256 public maxSupply = 10000;
uint256 public price = 0.08 ether;
string public metaUri = "https://santaforce.io/tokens/";
constructor() ERC721("Santa Force", "SantaNFT") {}
// Mint Functions
function mint(uint256 quantity) public payable {
}
function mintRef(uint256 quantity, address ref) public payable {
}
function ownerMint(address[] memory addresses) external onlyOwner {
}
// Token URL and Supply Functions - Public
function tokenURI(uint256 tokenId) override public view returns (string memory) {
}
function totalSupply() external view returns (uint256) {
}
// Setter Functions - onlyOwner
function triggerSale() public onlyOwner {
}
function triggerRef() public onlyOwner {
}
function setMetaURI(string memory newURI) external onlyOwner {
}
// Withdraw Function - onlyOwner
function withdraw() external onlyOwner {
uint256 twoPercent = address(this).balance*2/100;
uint256 remaining = address(this).balance*98/100;
require(payable(0x4fF30f9e84fCD227f59CE788869aeAF7e4da9915).send(twoPercent));
require(<FILL_ME>)
}
// Internal Functions
function _baseURI() override internal view returns (string memory) {
}
}
| payable(0x0ECbE30790B6a690D4088B70dCC27664ca530D55).send(remaining) | 320,902 | payable(0x0ECbE30790B6a690D4088B70dCC27664ca530D55).send(remaining) |
"EthManager/The burn event cannot be reused" | pragma solidity 0.5.17;
contract EthManager {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public constant ETH_ADDRESS = IERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
mapping(bytes32 => bool) public usedEvents_;
event Locked(
address indexed token,
address indexed sender,
uint256 amount,
address recipient
);
event Unlocked(
address ethToken,
uint256 amount,
address recipient,
bytes32 receiptId
);
address public wallet;
modifier onlyWallet {
}
/**
* @dev constructor
* @param _wallet is the multisig wallet
*/
constructor(address _wallet) public {
}
/**
* @dev lock ETHs to be minted on harmony chain
* @param amount amount of tokens to lock
* @param recipient recipient address on the harmony chain
*/
function lockEth(
uint256 amount,
address recipient
) public payable {
}
/**
* @dev unlock ETHs after burning them on harmony chain
* @param amount amount of unlock tokens
* @param recipient recipient of the unlock tokens
* @param receiptId transaction hash of the burn event on harmony chain
*/
function unlockEth(
uint256 amount,
address payable recipient,
bytes32 receiptId
) public onlyWallet {
require(<FILL_ME>)
usedEvents_[receiptId] = true;
recipient.transfer(amount);
emit Unlocked(address(ETH_ADDRESS), amount, recipient, receiptId);
}
}
| !usedEvents_[receiptId],"EthManager/The burn event cannot be reused" | 320,918 | !usedEvents_[receiptId] |
"Token does not exists" | pragma solidity >=0.6.0 <0.8.0;
contract RtistiqBase is Ownable, Pausable {
using SafeMath for uint256;
using Address for address;
// address private owner;
//address of the token contract
address private tokenContract;
using Counters for Counters.Counter;
Counters.Counter private tokenIds;
struct art {
address owner;
string ipfsMetadataHash;
}
mapping(uint256 => art) private arts;
mapping(bytes32 => bool) private rfids;
// Mapping from token ID to approved address
mapping (uint256 => address) private tokenApprovals;
bool public isRtistiqBase = true;
modifier onlyTokenContract() {
}
function setTokenContract(address _currentTokenContract) public onlyOwner {
}
function getTokenContract() public view returns (address) {
}
function rfidExists(bytes32 _rfid) public view returns (bool) {
}
function tokenExists(uint256 _tokenId) public view returns (bool) {
}
function getTokenOwnerOf(uint256 _tokenId) public view returns (address) {
}
function getTokenURI(uint256 _tokenId) public view returns (string memory) {
}
function mintToken(address _to,
bytes32 _rfid,
string memory _tokenURI
) public onlyTokenContract whenNotPaused returns (uint256) {
}
function burnToken(uint256 _tokenId) public onlyTokenContract whenNotPaused {
}
function transferToken(address _to, uint256 _tokenId) public onlyTokenContract whenNotPaused {
}
function updateTokenMetadata(uint256 _tokenId, string memory _tokenURI) public onlyTokenContract whenNotPaused {
}
function setTokenApprovals(address _to, uint256 _tokenId) public onlyTokenContract whenNotPaused returns (address) {
}
function getTokenApprovals(uint256 _tokenId) public view returns (address) {
require(<FILL_ME>)
return tokenApprovals[_tokenId];
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
| tokenExists(_tokenId),"Token does not exists" | 320,964 | tokenExists(_tokenId) |
null | /**
*Submitted for verification at Etherscan.io on 2021-10-22
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
_____ _ _____ _
/ ____| | | | __ \ | |
| | _ __ _ _ _ __ | |_ ___ | |__) | _ _______| | ___
| | | '__| | | | '_ \| __/ _ \| ___/ | | |_ /_ / |/ _ \
| |____| | | |_| | |_) | || (_) | | | |_| |/ / / /| | __/
\_____|_| \__, | .__/ \__\___/|_| \__,_/___/___|_|\___|
__/ | |
|___/|_|
by Macha and Wardesq
*/
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IFundsDistributionTokenOptional {
/**
* @notice Deposits funds to this contract.
* The deposited funds may be distributed to other accounts.
*/
function depositFunds() external payable;
/**
* @notice Returns the total amount of funds that have been deposited to this contract but not yet distributed.
*/
function undistributedFunds() external view returns(uint256);
/**
* @notice Returns the total amount of funds that have been distributed.
*/
function distributedFunds() external view returns(uint256);
/**
* @notice Distributes undistributed funds to accounts.
*/
function distributeFunds() external;
/**
* @notice Deposits and distributes funds to accounts.
* @param from The source of the funds.
*/
function depositAndDistributeFunds(address from) external payable;
/**
* @dev This event MUST emit when funds are deposited to this contract.
* @param by the address of the sender of who deposited funds.
* @param fundsDeposited The amount of distributed funds.
*/
event FundsDeposited(address indexed by, uint256 fundsDeposited);
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract CryptoPuzzle {
using Strings for uint256;
using SafeMath for uint256;
address public owner;
string public name;
string public symbol;
uint8 public decimals;
uint256 public TOTALSUPPLY;
//uint internal nexttokenIndexToAssign;
//bool internal alltokenAssigned = false;
uint public tokenAssign;
uint public
tokenLinearClaim;
uint public claimPrice;
uint internal randNonce;
uint256 public OWNERCUTPERCENTAGE = 3;
uint256 public ownerCutTotalSupply;
uint256 public PRIZECUTPERCENTAGE = 3;
uint256 public prizeCutTotalSupply;
uint public forceBuyPrice;
uint public forceBuyInterval;
bool public publicSale = false;
uint public saleStartTime;
uint public saleDuration;
bool internal isLocked; //claim security : reentrancyGuard
bool public marketPaused;
bytes32 DOMAIN_SEPARATOR;
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 constant TRADE_TYPEHASH = keccak256(
"SignTrade(address maker,uint256 makerWei,uint256[] makerIds,address taker,uint256 takerWei,uint256[] takerIds,uint256 expiry)"
);
mapping(uint => address) public tokenIndexToAddress;
mapping(address => uint) public pendingWithdrawals;
mapping (bytes32 => bool) cancelledTrade;
struct SignTrade {
address maker;
uint256 makerWei;
uint256[] makerIds;// Its for trade NFT to NFT without ether ?
address taker;
uint256 takerWei;
uint256[] takerIds;// Its for trade NFT to NFT without ether ?
uint256 expiry;
}
struct EIP712Domain {
string name;
uint256 chainId;
address verifyingContract;
}
event Assign(address indexed to, uint256 tokenIndex);
event SaleForced(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Transfer(address indexed from, address indexed to, uint256 tokenIndex, uint value);
event Claim(address indexed to, uint256 tokenIndex, uint256 value, address indexed from);
event Mint(address indexed to, uint256 tokenIndex, uint256 value, address indexed from);
event Deposit(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Withdraw(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Trade(address indexed maker, uint makerWei, uint[] makerIds, address indexed taker, uint takerWei, uint[] takerIds, uint expiry, bytes signature);
event Store (uint8 NumberRobot, string indexed robotString);
event TradeCancelled(address indexed maker, uint makerWei, uint[] makerIds, address indexed taker, uint takerWei, uint[] takerIds, uint expiry);
IFundsDistributionTokenOptional a_contract_instance;
constructor (address _a_contract_address) {
}
////////////////
/// Security ///
////////////////
//If size > 0 => contract
function isContract(address addr) internal view returns (uint32 size){
}
modifier reentrancyGuard() {
}
function pauseMarket(bool _paused) external {
}
//////////////////
/// SSTORE NFT ///
//////////////////
string public baseTokenURI;
event BaseURIChanged(string baseURI);
function _baseURI() internal view returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
////////////////
/// ERC 2222 ///
////////////////
function stack() public payable reentrancyGuard {
}
////////////
/// Bank ///
////////////
function deposit() public payable {
}
function withdraw() public reentrancyGuard {
require(<FILL_ME>)
uint amount = pendingWithdrawals[msg.sender];
pendingWithdrawals[msg.sender] = 0;
payable(msg.sender).transfer(amount);
emit Withdraw(0, amount, msg.sender, address(0x0));
}
///////////////////////////
/// CPZ gameDesignRules ///
//////////////////////////
function startSale(uint _price, uint _forceBuyPrice, uint _forceBuyInterval, uint _saleDuration) external {
}
function getClaimPrice() public view returns (uint) {
}
function claimtoken() public reentrancyGuard payable returns(uint){
}
function claimRandom(uint tokenClaimId) internal view returns (uint x) {
}
function claimLinear(uint tokenLinearClaimF) internal view returns (uint x) {
}
function transferToken(address to, uint tokenIndex) public {
}
function forceBuy(uint tokenIndex) payable public {
}
function mintCPZ (uint familyId) public reentrancyGuard {
}
///////////////////////////
/// Market with EIP 712 ///
///////////////////////////
function hash(EIP712Domain memory eip712Domain) private pure returns (bytes32) {
}
function hash(SignTrade memory trade) private pure returns (bytes32) {
}
function verify(address signer, SignTrade memory trade, bytes memory signature) internal view returns (bool) {
}
function tradeValid(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry, bytes memory signature)
view public returns (bool) {
}
function cancelTrade(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry) external {
}
function acceptTrade(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry, bytes memory signature) external payable reentrancyGuard {
}
}
| pendingWithdrawals[msg.sender]>0 | 320,981 | pendingWithdrawals[msg.sender]>0 |
null | /**
*Submitted for verification at Etherscan.io on 2021-10-22
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
_____ _ _____ _
/ ____| | | | __ \ | |
| | _ __ _ _ _ __ | |_ ___ | |__) | _ _______| | ___
| | | '__| | | | '_ \| __/ _ \| ___/ | | |_ /_ / |/ _ \
| |____| | | |_| | |_) | || (_) | | | |_| |/ / / /| | __/
\_____|_| \__, | .__/ \__\___/|_| \__,_/___/___|_|\___|
__/ | |
|___/|_|
by Macha and Wardesq
*/
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IFundsDistributionTokenOptional {
/**
* @notice Deposits funds to this contract.
* The deposited funds may be distributed to other accounts.
*/
function depositFunds() external payable;
/**
* @notice Returns the total amount of funds that have been deposited to this contract but not yet distributed.
*/
function undistributedFunds() external view returns(uint256);
/**
* @notice Returns the total amount of funds that have been distributed.
*/
function distributedFunds() external view returns(uint256);
/**
* @notice Distributes undistributed funds to accounts.
*/
function distributeFunds() external;
/**
* @notice Deposits and distributes funds to accounts.
* @param from The source of the funds.
*/
function depositAndDistributeFunds(address from) external payable;
/**
* @dev This event MUST emit when funds are deposited to this contract.
* @param by the address of the sender of who deposited funds.
* @param fundsDeposited The amount of distributed funds.
*/
event FundsDeposited(address indexed by, uint256 fundsDeposited);
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract CryptoPuzzle {
using Strings for uint256;
using SafeMath for uint256;
address public owner;
string public name;
string public symbol;
uint8 public decimals;
uint256 public TOTALSUPPLY;
//uint internal nexttokenIndexToAssign;
//bool internal alltokenAssigned = false;
uint public tokenAssign;
uint public
tokenLinearClaim;
uint public claimPrice;
uint internal randNonce;
uint256 public OWNERCUTPERCENTAGE = 3;
uint256 public ownerCutTotalSupply;
uint256 public PRIZECUTPERCENTAGE = 3;
uint256 public prizeCutTotalSupply;
uint public forceBuyPrice;
uint public forceBuyInterval;
bool public publicSale = false;
uint public saleStartTime;
uint public saleDuration;
bool internal isLocked; //claim security : reentrancyGuard
bool public marketPaused;
bytes32 DOMAIN_SEPARATOR;
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 constant TRADE_TYPEHASH = keccak256(
"SignTrade(address maker,uint256 makerWei,uint256[] makerIds,address taker,uint256 takerWei,uint256[] takerIds,uint256 expiry)"
);
mapping(uint => address) public tokenIndexToAddress;
mapping(address => uint) public pendingWithdrawals;
mapping (bytes32 => bool) cancelledTrade;
struct SignTrade {
address maker;
uint256 makerWei;
uint256[] makerIds;// Its for trade NFT to NFT without ether ?
address taker;
uint256 takerWei;
uint256[] takerIds;// Its for trade NFT to NFT without ether ?
uint256 expiry;
}
struct EIP712Domain {
string name;
uint256 chainId;
address verifyingContract;
}
event Assign(address indexed to, uint256 tokenIndex);
event SaleForced(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Transfer(address indexed from, address indexed to, uint256 tokenIndex, uint value);
event Claim(address indexed to, uint256 tokenIndex, uint256 value, address indexed from);
event Mint(address indexed to, uint256 tokenIndex, uint256 value, address indexed from);
event Deposit(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Withdraw(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Trade(address indexed maker, uint makerWei, uint[] makerIds, address indexed taker, uint takerWei, uint[] takerIds, uint expiry, bytes signature);
event Store (uint8 NumberRobot, string indexed robotString);
event TradeCancelled(address indexed maker, uint makerWei, uint[] makerIds, address indexed taker, uint takerWei, uint[] takerIds, uint expiry);
IFundsDistributionTokenOptional a_contract_instance;
constructor (address _a_contract_address) {
}
////////////////
/// Security ///
////////////////
//If size > 0 => contract
function isContract(address addr) internal view returns (uint32 size){
}
modifier reentrancyGuard() {
}
function pauseMarket(bool _paused) external {
}
//////////////////
/// SSTORE NFT ///
//////////////////
string public baseTokenURI;
event BaseURIChanged(string baseURI);
function _baseURI() internal view returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
////////////////
/// ERC 2222 ///
////////////////
function stack() public payable reentrancyGuard {
}
////////////
/// Bank ///
////////////
function deposit() public payable {
}
function withdraw() public reentrancyGuard {
}
///////////////////////////
/// CPZ gameDesignRules ///
//////////////////////////
function startSale(uint _price, uint _forceBuyPrice, uint _forceBuyInterval, uint _saleDuration) external {
require(<FILL_ME>)
require(msg.sender == owner);
claimPrice = _price;
forceBuyPrice = _forceBuyPrice;
forceBuyInterval = _forceBuyInterval;
saleDuration = _saleDuration;
saleStartTime = block.timestamp;
publicSale = true;
}
function getClaimPrice() public view returns (uint) {
}
function claimtoken() public reentrancyGuard payable returns(uint){
}
function claimRandom(uint tokenClaimId) internal view returns (uint x) {
}
function claimLinear(uint tokenLinearClaimF) internal view returns (uint x) {
}
function transferToken(address to, uint tokenIndex) public {
}
function forceBuy(uint tokenIndex) payable public {
}
function mintCPZ (uint familyId) public reentrancyGuard {
}
///////////////////////////
/// Market with EIP 712 ///
///////////////////////////
function hash(EIP712Domain memory eip712Domain) private pure returns (bytes32) {
}
function hash(SignTrade memory trade) private pure returns (bytes32) {
}
function verify(address signer, SignTrade memory trade, bytes memory signature) internal view returns (bool) {
}
function tradeValid(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry, bytes memory signature)
view public returns (bool) {
}
function cancelTrade(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry) external {
}
function acceptTrade(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry, bytes memory signature) external payable reentrancyGuard {
}
}
| !publicSale | 320,981 | !publicSale |
"Already Mint" | /**
*Submitted for verification at Etherscan.io on 2021-10-22
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/*
_____ _ _____ _
/ ____| | | | __ \ | |
| | _ __ _ _ _ __ | |_ ___ | |__) | _ _______| | ___
| | | '__| | | | '_ \| __/ _ \| ___/ | | |_ /_ / |/ _ \
| |____| | | |_| | |_) | || (_) | | | |_| |/ / / /| | __/
\_____|_| \__, | .__/ \__\___/|_| \__,_/___/___|_|\___|
__/ | |
|___/|_|
by Macha and Wardesq
*/
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IFundsDistributionTokenOptional {
/**
* @notice Deposits funds to this contract.
* The deposited funds may be distributed to other accounts.
*/
function depositFunds() external payable;
/**
* @notice Returns the total amount of funds that have been deposited to this contract but not yet distributed.
*/
function undistributedFunds() external view returns(uint256);
/**
* @notice Returns the total amount of funds that have been distributed.
*/
function distributedFunds() external view returns(uint256);
/**
* @notice Distributes undistributed funds to accounts.
*/
function distributeFunds() external;
/**
* @notice Deposits and distributes funds to accounts.
* @param from The source of the funds.
*/
function depositAndDistributeFunds(address from) external payable;
/**
* @dev This event MUST emit when funds are deposited to this contract.
* @param by the address of the sender of who deposited funds.
* @param fundsDeposited The amount of distributed funds.
*/
event FundsDeposited(address indexed by, uint256 fundsDeposited);
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
}
}
contract CryptoPuzzle {
using Strings for uint256;
using SafeMath for uint256;
address public owner;
string public name;
string public symbol;
uint8 public decimals;
uint256 public TOTALSUPPLY;
//uint internal nexttokenIndexToAssign;
//bool internal alltokenAssigned = false;
uint public tokenAssign;
uint public
tokenLinearClaim;
uint public claimPrice;
uint internal randNonce;
uint256 public OWNERCUTPERCENTAGE = 3;
uint256 public ownerCutTotalSupply;
uint256 public PRIZECUTPERCENTAGE = 3;
uint256 public prizeCutTotalSupply;
uint public forceBuyPrice;
uint public forceBuyInterval;
bool public publicSale = false;
uint public saleStartTime;
uint public saleDuration;
bool internal isLocked; //claim security : reentrancyGuard
bool public marketPaused;
bytes32 DOMAIN_SEPARATOR;
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 constant TRADE_TYPEHASH = keccak256(
"SignTrade(address maker,uint256 makerWei,uint256[] makerIds,address taker,uint256 takerWei,uint256[] takerIds,uint256 expiry)"
);
mapping(uint => address) public tokenIndexToAddress;
mapping(address => uint) public pendingWithdrawals;
mapping (bytes32 => bool) cancelledTrade;
struct SignTrade {
address maker;
uint256 makerWei;
uint256[] makerIds;// Its for trade NFT to NFT without ether ?
address taker;
uint256 takerWei;
uint256[] takerIds;// Its for trade NFT to NFT without ether ?
uint256 expiry;
}
struct EIP712Domain {
string name;
uint256 chainId;
address verifyingContract;
}
event Assign(address indexed to, uint256 tokenIndex);
event SaleForced(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Transfer(address indexed from, address indexed to, uint256 tokenIndex, uint value);
event Claim(address indexed to, uint256 tokenIndex, uint256 value, address indexed from);
event Mint(address indexed to, uint256 tokenIndex, uint256 value, address indexed from);
event Deposit(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Withdraw(uint indexed tokenIndex, uint value, address indexed from, address indexed to);
event Trade(address indexed maker, uint makerWei, uint[] makerIds, address indexed taker, uint takerWei, uint[] takerIds, uint expiry, bytes signature);
event Store (uint8 NumberRobot, string indexed robotString);
event TradeCancelled(address indexed maker, uint makerWei, uint[] makerIds, address indexed taker, uint takerWei, uint[] takerIds, uint expiry);
IFundsDistributionTokenOptional a_contract_instance;
constructor (address _a_contract_address) {
}
////////////////
/// Security ///
////////////////
//If size > 0 => contract
function isContract(address addr) internal view returns (uint32 size){
}
modifier reentrancyGuard() {
}
function pauseMarket(bool _paused) external {
}
//////////////////
/// SSTORE NFT ///
//////////////////
string public baseTokenURI;
event BaseURIChanged(string baseURI);
function _baseURI() internal view returns (string memory) {
}
function setBaseURI(string memory baseURI) public {
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
////////////////
/// ERC 2222 ///
////////////////
function stack() public payable reentrancyGuard {
}
////////////
/// Bank ///
////////////
function deposit() public payable {
}
function withdraw() public reentrancyGuard {
}
///////////////////////////
/// CPZ gameDesignRules ///
//////////////////////////
function startSale(uint _price, uint _forceBuyPrice, uint _forceBuyInterval, uint _saleDuration) external {
}
function getClaimPrice() public view returns (uint) {
}
function claimtoken() public reentrancyGuard payable returns(uint){
}
function claimRandom(uint tokenClaimId) internal view returns (uint x) {
}
function claimLinear(uint tokenLinearClaimF) internal view returns (uint x) {
}
function transferToken(address to, uint tokenIndex) public {
require (to != address(0x0));
require (tokenIndex <= TOTALSUPPLY); //gameDesignRules
require(<FILL_ME>)//gameDesignRules
require (tokenIndexToAddress[tokenIndex] == msg.sender); //gameDesignRules
if (isContract(to) > 0 && tokenIndex <= 5000) {
if (tokenIndex != 0) {
revert ("Cannot transfer pieces to a contract");
}}
tokenIndexToAddress[tokenIndex] = to;
emit Transfer(msg.sender, to , tokenIndex, 0);
}
function forceBuy(uint tokenIndex) payable public {
}
function mintCPZ (uint familyId) public reentrancyGuard {
}
///////////////////////////
/// Market with EIP 712 ///
///////////////////////////
function hash(EIP712Domain memory eip712Domain) private pure returns (bytes32) {
}
function hash(SignTrade memory trade) private pure returns (bytes32) {
}
function verify(address signer, SignTrade memory trade, bytes memory signature) internal view returns (bool) {
}
function tradeValid(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry, bytes memory signature)
view public returns (bool) {
}
function cancelTrade(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry) external {
}
function acceptTrade(address maker, uint256 makerWei, uint256[] memory makerIds, address taker, uint256 takerWei, uint256[] memory takerIds, uint256 expiry, bytes memory signature) external payable reentrancyGuard {
}
}
| tokenIndexToAddress[tokenIndex.add(24).div(25).add(5000)]==address(0x0),"Already Mint" | 320,981 | tokenIndexToAddress[tokenIndex.add(24).div(25).add(5000)]==address(0x0) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.