comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
null | pragma solidity ^0.4.18;
/* ==================================================================== */
/* Copyright (c) 2018 The MagicAcademy Project. All rights reserved.
/*
/* https://www.magicacademy.io One of the world's first idle strategy games of blockchain
/*
/* authors [email protected]/[email protected]
/*
/* ==================================================================== */
/**
* @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 {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts 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) {
}
}
interface CardsInterface {
function getJadeProduction(address player) external constant returns (uint256);
function getUpgradeValue(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) external view returns (uint256);
function getGameStarted() external constant returns (bool);
function balanceOf(address player) external constant returns(uint256);
function balanceOfUnclaimed(address player) external constant returns (uint256);
function coinBalanceOf(address player,uint8 itype) external constant returns(uint256);
function setCoinBalance(address player, uint256 eth, uint8 itype, bool iflag) external;
function setJadeCoin(address player, uint256 coin, bool iflag) external;
function setJadeCoinZero(address player) external;
function setLastJadeSaveTime(address player) external;
function setRoughSupply(uint256 iroughSupply) external;
function updatePlayersCoinByPurchase(address player, uint256 purchaseCost) external;
function updatePlayersCoinByOut(address player) external;
function increasePlayersJadeProduction(address player, uint256 increase) external;
function reducePlayersJadeProduction(address player, uint256 decrease) external;
function getUintsOwnerCount(address _address) external view returns (uint256);
function setUintsOwnerCount(address _address, uint256 amount, bool iflag) external;
function getOwnedCount(address player, uint256 cardId) external view returns (uint256);
function setOwnedCount(address player, uint256 cardId, uint256 amount, bool iflag) external;
function getUpgradesOwned(address player, uint256 upgradeId) external view returns (uint256);
function setUpgradesOwned(address player, uint256 upgradeId) external;
function getTotalEtherPool(uint8 itype) external view returns (uint256);
function setTotalEtherPool(uint256 inEth, uint8 itype, bool iflag) external;
function setNextSnapshotTime(uint256 iTime) external;
function getNextSnapshotTime() external view;
function AddPlayers(address _address) external;
function getTotalUsers() external view returns (uint256);
function getRanking() external view returns (address[] addr, uint256[] _arr);
function getAttackRanking() external view returns (address[] addr, uint256[] _arr);
function getUnitsProduction(address player, uint256 cardId, uint256 amount) external constant returns (uint256);
function getUnitCoinProductionIncreases(address _address, uint256 cardId) external view returns (uint256);
function setUnitCoinProductionIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function getUnitCoinProductionMultiplier(address _address, uint256 cardId) external view returns (uint256);
function setUnitCoinProductionMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitAttackIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitAttackMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitDefenseIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setunitDefenseMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitJadeStealingIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitJadeStealingMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUintCoinProduction(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function getUintCoinProduction(address _address, uint256 cardId) external returns (uint256);
function getUnitsInProduction(address player, uint256 unitId, uint256 amount) external constant returns (uint256);
function getPlayersBattleStats(address player) public constant returns (
uint256 attackingPower,
uint256 defendingPower,
uint256 stealingPower,
uint256 battlePower);
}
interface GameConfigInterface {
function getMaxCAP() external returns (uint256);
function unitCoinProduction(uint256 cardId) external constant returns (uint256);
function unitPLATCost(uint256 cardId) external constant returns (uint256);
function getCostForCards(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256);
function getCostForBattleCards(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256);
function unitBattlePLATCost(uint256 cardId) external constant returns (uint256);
function getUpgradeCardsInfo(uint256 upgradecardId,uint256 existing) external constant returns (
uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost
);
function getCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, uint256, bool);
function getBattleCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, bool);
}
interface RareInterface {
function getRareItemsOwner(uint256 rareId) external view returns (address);
function getRareItemsPrice(uint256 rareId) external view returns (uint256);
function getRareItemsPLATPrice(uint256 rareId) external view returns (uint256);
function getRarePLATInfo(uint256 _tokenId) external view returns (
uint256 sellingPrice,
address owner,
uint256 nextPrice,
uint256 rareClass,
uint256 cardId,
uint256 rareValue
);
function transferToken(address _from, address _to, uint256 _tokenId) external;
function setRarePrice(uint256 _rareId, uint256 _price) external;
}
contract BitGuildHelper is Ownable {
//data contract
CardsInterface public cards ;
GameConfigInterface public schema;
RareInterface public rare;
function setCardsAddress(address _address) external onlyOwner {
}
//normal cards
function setConfigAddress(address _address) external onlyOwner {
}
//rare cards
function setRareAddress(address _address) external onlyOwner {
}
/// add multiplier
function upgradeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
}
/// move multipliers
function removeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
}
}
interface BitGuildTokenInterface { // implements ERC20Interface
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
/// @notice Purchase on BitGuild
contract BitGuildTrade is BitGuildHelper {
BitGuildTokenInterface public tokenContract;
event UnitBought(address player, uint256 unitId, uint256 amount);
event UpgradeCardBought(address player, uint256 upgradeId);
event BuyRareCard(address player, address previous, uint256 rareId,uint256 iPrice);
event UnitSold(address player, uint256 unitId, uint256 amount);
mapping(address => mapping(uint256 => uint256)) unitsOwnedOfPLAT; //cards bought through plat
function() external payable {
}
function setBitGuildToken(address _tokenContract) external {
}
function kill() public onlyOwner {
}
/// @notice Returns all the relevant information about a specific tokenId.
/// val1:flag,val2:id,val3:amount
function _getExtraParam(bytes _extraData) private pure returns(uint256 val1,uint256 val2,uint256 val3) {
}
function receiveApproval(address _player, uint256 _value, address _tokenContractAddr, bytes _extraData) external {
}
function buyPLATCards(address _player, uint256 _platValue, uint256 _cardId, uint256 _amount) internal {
require(cards.getGameStarted());
require(_amount>=1);
uint256 existing = cards.getOwnedCount(_player,_cardId);
require(existing < schema.getMaxCAP());
uint256 iAmount;
if (SafeMath.add(existing, _amount) > schema.getMaxCAP()) {
iAmount = SafeMath.sub(schema.getMaxCAP(),existing);
} else {
iAmount = _amount;
}
uint256 coinProduction;
uint256 coinCost;
uint256 ethCost;
if (_cardId>=1 && _cardId<=39) {
coinProduction = schema.unitCoinProduction(_cardId);
coinCost = schema.getCostForCards(_cardId, existing, iAmount);
ethCost = SafeMath.mul(schema.unitPLATCost(_cardId),iAmount); // get platprice
} else if (_cardId>=40) {
coinCost = schema.getCostForBattleCards(_cardId, existing, iAmount);
ethCost = SafeMath.mul(schema.unitBattlePLATCost(_cardId),iAmount); // get platprice
}
require(ethCost>0);
require(SafeMath.add(cards.coinBalanceOf(_player,1),_platValue) >= ethCost);
require(<FILL_ME>)
// Update players jade
cards.updatePlayersCoinByPurchase(_player, coinCost);
if (ethCost > _platValue) {
cards.setCoinBalance(_player,SafeMath.sub(ethCost,_platValue),1,false);
} else if (_platValue > ethCost) {
// Store overbid in their balance
cards.setCoinBalance(_player,SafeMath.sub(_platValue,ethCost),1,true);
}
uint256 devFund = uint256(SafeMath.div(ethCost,20)); // 5% fee
cards.setTotalEtherPool(uint256(SafeMath.div(ethCost,4)),1,true); // 20% to pool
cards.setCoinBalance(owner,devFund,1,true);
if (coinProduction > 0) {
cards.increasePlayersJadeProduction(_player, cards.getUnitsProduction(_player, _cardId, iAmount));
cards.setUintCoinProduction(_player,_cardId,cards.getUnitsProduction(_player, _cardId, iAmount),true);
}
if (cards.getUintsOwnerCount(_player)<=0) {
cards.AddPlayers(_player);
}
cards.setUintsOwnerCount(_player,iAmount, true);
cards.setOwnedCount(_player,_cardId,iAmount,true);
unitsOwnedOfPLAT[_player][_cardId] = SafeMath.add(unitsOwnedOfPLAT[_player][_cardId],iAmount);
//event
UnitBought(_player, _cardId, iAmount);
}
/// upgrade cards-- jade + plat
function buyUpgradeCard(address _player, uint256 _platValue,uint256 _upgradeId) internal {
}
// Allows someone to send ether and obtain the token
function buyRareItem(address _player, uint256 _platValue,uint256 _rareId) internal {
}
/// refunds 75% since no transfer between bitguild and player,no need to call approveAndCall
function sellCards( uint256 _unitId, uint256 _amount) external {
}
//@notice for player withdraw
function withdrawEtherFromTrade(uint256 amount) external {
}
//@notice withraw all PLAT by dev
function withdrawToken(uint256 amount) external onlyOwner {
}
function getCanSellUnit(address _address, uint256 unitId) external view returns (uint256) {
}
}
| cards.balanceOf(_player)>=coinCost | 398,149 | cards.balanceOf(_player)>=coinCost |
null | pragma solidity ^0.4.18;
/* ==================================================================== */
/* Copyright (c) 2018 The MagicAcademy Project. All rights reserved.
/*
/* https://www.magicacademy.io One of the world's first idle strategy games of blockchain
/*
/* authors [email protected]/[email protected]
/*
/* ==================================================================== */
/**
* @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 {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts 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) {
}
}
interface CardsInterface {
function getJadeProduction(address player) external constant returns (uint256);
function getUpgradeValue(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) external view returns (uint256);
function getGameStarted() external constant returns (bool);
function balanceOf(address player) external constant returns(uint256);
function balanceOfUnclaimed(address player) external constant returns (uint256);
function coinBalanceOf(address player,uint8 itype) external constant returns(uint256);
function setCoinBalance(address player, uint256 eth, uint8 itype, bool iflag) external;
function setJadeCoin(address player, uint256 coin, bool iflag) external;
function setJadeCoinZero(address player) external;
function setLastJadeSaveTime(address player) external;
function setRoughSupply(uint256 iroughSupply) external;
function updatePlayersCoinByPurchase(address player, uint256 purchaseCost) external;
function updatePlayersCoinByOut(address player) external;
function increasePlayersJadeProduction(address player, uint256 increase) external;
function reducePlayersJadeProduction(address player, uint256 decrease) external;
function getUintsOwnerCount(address _address) external view returns (uint256);
function setUintsOwnerCount(address _address, uint256 amount, bool iflag) external;
function getOwnedCount(address player, uint256 cardId) external view returns (uint256);
function setOwnedCount(address player, uint256 cardId, uint256 amount, bool iflag) external;
function getUpgradesOwned(address player, uint256 upgradeId) external view returns (uint256);
function setUpgradesOwned(address player, uint256 upgradeId) external;
function getTotalEtherPool(uint8 itype) external view returns (uint256);
function setTotalEtherPool(uint256 inEth, uint8 itype, bool iflag) external;
function setNextSnapshotTime(uint256 iTime) external;
function getNextSnapshotTime() external view;
function AddPlayers(address _address) external;
function getTotalUsers() external view returns (uint256);
function getRanking() external view returns (address[] addr, uint256[] _arr);
function getAttackRanking() external view returns (address[] addr, uint256[] _arr);
function getUnitsProduction(address player, uint256 cardId, uint256 amount) external constant returns (uint256);
function getUnitCoinProductionIncreases(address _address, uint256 cardId) external view returns (uint256);
function setUnitCoinProductionIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function getUnitCoinProductionMultiplier(address _address, uint256 cardId) external view returns (uint256);
function setUnitCoinProductionMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitAttackIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitAttackMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitDefenseIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setunitDefenseMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitJadeStealingIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitJadeStealingMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUintCoinProduction(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function getUintCoinProduction(address _address, uint256 cardId) external returns (uint256);
function getUnitsInProduction(address player, uint256 unitId, uint256 amount) external constant returns (uint256);
function getPlayersBattleStats(address player) public constant returns (
uint256 attackingPower,
uint256 defendingPower,
uint256 stealingPower,
uint256 battlePower);
}
interface GameConfigInterface {
function getMaxCAP() external returns (uint256);
function unitCoinProduction(uint256 cardId) external constant returns (uint256);
function unitPLATCost(uint256 cardId) external constant returns (uint256);
function getCostForCards(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256);
function getCostForBattleCards(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256);
function unitBattlePLATCost(uint256 cardId) external constant returns (uint256);
function getUpgradeCardsInfo(uint256 upgradecardId,uint256 existing) external constant returns (
uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost
);
function getCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, uint256, bool);
function getBattleCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, bool);
}
interface RareInterface {
function getRareItemsOwner(uint256 rareId) external view returns (address);
function getRareItemsPrice(uint256 rareId) external view returns (uint256);
function getRareItemsPLATPrice(uint256 rareId) external view returns (uint256);
function getRarePLATInfo(uint256 _tokenId) external view returns (
uint256 sellingPrice,
address owner,
uint256 nextPrice,
uint256 rareClass,
uint256 cardId,
uint256 rareValue
);
function transferToken(address _from, address _to, uint256 _tokenId) external;
function setRarePrice(uint256 _rareId, uint256 _price) external;
}
contract BitGuildHelper is Ownable {
//data contract
CardsInterface public cards ;
GameConfigInterface public schema;
RareInterface public rare;
function setCardsAddress(address _address) external onlyOwner {
}
//normal cards
function setConfigAddress(address _address) external onlyOwner {
}
//rare cards
function setRareAddress(address _address) external onlyOwner {
}
/// add multiplier
function upgradeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
}
/// move multipliers
function removeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
}
}
interface BitGuildTokenInterface { // implements ERC20Interface
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
/// @notice Purchase on BitGuild
contract BitGuildTrade is BitGuildHelper {
BitGuildTokenInterface public tokenContract;
event UnitBought(address player, uint256 unitId, uint256 amount);
event UpgradeCardBought(address player, uint256 upgradeId);
event BuyRareCard(address player, address previous, uint256 rareId,uint256 iPrice);
event UnitSold(address player, uint256 unitId, uint256 amount);
mapping(address => mapping(uint256 => uint256)) unitsOwnedOfPLAT; //cards bought through plat
function() external payable {
}
function setBitGuildToken(address _tokenContract) external {
}
function kill() public onlyOwner {
}
/// @notice Returns all the relevant information about a specific tokenId.
/// val1:flag,val2:id,val3:amount
function _getExtraParam(bytes _extraData) private pure returns(uint256 val1,uint256 val2,uint256 val3) {
}
function receiveApproval(address _player, uint256 _value, address _tokenContractAddr, bytes _extraData) external {
}
function buyPLATCards(address _player, uint256 _platValue, uint256 _cardId, uint256 _amount) internal {
}
/// upgrade cards-- jade + plat
function buyUpgradeCard(address _player, uint256 _platValue,uint256 _upgradeId) internal {
require(cards.getGameStarted());
require(_upgradeId>=1);
uint256 existing = cards.getUpgradesOwned(_player,_upgradeId);
require(existing<=5); // v1 - v6
uint256 coinCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
uint256 platCost;
(coinCost, ethCost, upgradeClass, unitId, upgradeValue,platCost) = schema.getUpgradeCardsInfo(_upgradeId,existing);
require(platCost>0);
if (platCost > 0) {
require(<FILL_ME>)
if (platCost > _platValue) { // They can use their balance instead
cards.setCoinBalance(_player, SafeMath.sub(platCost,_platValue),1,false);
} else if (platCost < _platValue) {
cards.setCoinBalance(_player,SafeMath.sub(_platValue,platCost),1,true);
}
// defund 5%，upgrade card can not be sold，
uint256 devFund = uint256(SafeMath.div(platCost, 20)); // 5% fee on purchases (marketing, gameplay & maintenance)
cards.setTotalEtherPool(SafeMath.sub(platCost,devFund),1,true); // Rest goes to div pool (Can't sell upgrades)
cards.setCoinBalance(owner,devFund,1,true);
}
// Update
require(cards.balanceOf(_player) >= coinCost);
cards.updatePlayersCoinByPurchase(_player, coinCost);
//add weight
upgradeUnitMultipliers(_player, upgradeClass, unitId, upgradeValue);
cards.setUpgradesOwned(_player,_upgradeId); // upgrade level up
//add user to userlist
if (cards.getUintsOwnerCount(_player)<=0) {
cards.AddPlayers(_player);
}
UpgradeCardBought(_player, _upgradeId);
}
// Allows someone to send ether and obtain the token
function buyRareItem(address _player, uint256 _platValue,uint256 _rareId) internal {
}
/// refunds 75% since no transfer between bitguild and player,no need to call approveAndCall
function sellCards( uint256 _unitId, uint256 _amount) external {
}
//@notice for player withdraw
function withdrawEtherFromTrade(uint256 amount) external {
}
//@notice withraw all PLAT by dev
function withdrawToken(uint256 amount) external onlyOwner {
}
function getCanSellUnit(address _address, uint256 unitId) external view returns (uint256) {
}
}
| SafeMath.add(cards.coinBalanceOf(_player,1),_platValue)>=platCost | 398,149 | SafeMath.add(cards.coinBalanceOf(_player,1),_platValue)>=platCost |
null | pragma solidity ^0.4.18;
/* ==================================================================== */
/* Copyright (c) 2018 The MagicAcademy Project. All rights reserved.
/*
/* https://www.magicacademy.io One of the world's first idle strategy games of blockchain
/*
/* authors [email protected]/[email protected]
/*
/* ==================================================================== */
/**
* @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 {
}
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts 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) {
}
}
interface CardsInterface {
function getJadeProduction(address player) external constant returns (uint256);
function getUpgradeValue(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) external view returns (uint256);
function getGameStarted() external constant returns (bool);
function balanceOf(address player) external constant returns(uint256);
function balanceOfUnclaimed(address player) external constant returns (uint256);
function coinBalanceOf(address player,uint8 itype) external constant returns(uint256);
function setCoinBalance(address player, uint256 eth, uint8 itype, bool iflag) external;
function setJadeCoin(address player, uint256 coin, bool iflag) external;
function setJadeCoinZero(address player) external;
function setLastJadeSaveTime(address player) external;
function setRoughSupply(uint256 iroughSupply) external;
function updatePlayersCoinByPurchase(address player, uint256 purchaseCost) external;
function updatePlayersCoinByOut(address player) external;
function increasePlayersJadeProduction(address player, uint256 increase) external;
function reducePlayersJadeProduction(address player, uint256 decrease) external;
function getUintsOwnerCount(address _address) external view returns (uint256);
function setUintsOwnerCount(address _address, uint256 amount, bool iflag) external;
function getOwnedCount(address player, uint256 cardId) external view returns (uint256);
function setOwnedCount(address player, uint256 cardId, uint256 amount, bool iflag) external;
function getUpgradesOwned(address player, uint256 upgradeId) external view returns (uint256);
function setUpgradesOwned(address player, uint256 upgradeId) external;
function getTotalEtherPool(uint8 itype) external view returns (uint256);
function setTotalEtherPool(uint256 inEth, uint8 itype, bool iflag) external;
function setNextSnapshotTime(uint256 iTime) external;
function getNextSnapshotTime() external view;
function AddPlayers(address _address) external;
function getTotalUsers() external view returns (uint256);
function getRanking() external view returns (address[] addr, uint256[] _arr);
function getAttackRanking() external view returns (address[] addr, uint256[] _arr);
function getUnitsProduction(address player, uint256 cardId, uint256 amount) external constant returns (uint256);
function getUnitCoinProductionIncreases(address _address, uint256 cardId) external view returns (uint256);
function setUnitCoinProductionIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function getUnitCoinProductionMultiplier(address _address, uint256 cardId) external view returns (uint256);
function setUnitCoinProductionMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitAttackIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitAttackMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitDefenseIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setunitDefenseMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitJadeStealingIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUnitJadeStealingMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function setUintCoinProduction(address _address, uint256 cardId, uint256 iValue,bool iflag) external;
function getUintCoinProduction(address _address, uint256 cardId) external returns (uint256);
function getUnitsInProduction(address player, uint256 unitId, uint256 amount) external constant returns (uint256);
function getPlayersBattleStats(address player) public constant returns (
uint256 attackingPower,
uint256 defendingPower,
uint256 stealingPower,
uint256 battlePower);
}
interface GameConfigInterface {
function getMaxCAP() external returns (uint256);
function unitCoinProduction(uint256 cardId) external constant returns (uint256);
function unitPLATCost(uint256 cardId) external constant returns (uint256);
function getCostForCards(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256);
function getCostForBattleCards(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256);
function unitBattlePLATCost(uint256 cardId) external constant returns (uint256);
function getUpgradeCardsInfo(uint256 upgradecardId,uint256 existing) external constant returns (
uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost
);
function getCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, uint256, bool);
function getBattleCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns (uint256, uint256, uint256, bool);
}
interface RareInterface {
function getRareItemsOwner(uint256 rareId) external view returns (address);
function getRareItemsPrice(uint256 rareId) external view returns (uint256);
function getRareItemsPLATPrice(uint256 rareId) external view returns (uint256);
function getRarePLATInfo(uint256 _tokenId) external view returns (
uint256 sellingPrice,
address owner,
uint256 nextPrice,
uint256 rareClass,
uint256 cardId,
uint256 rareValue
);
function transferToken(address _from, address _to, uint256 _tokenId) external;
function setRarePrice(uint256 _rareId, uint256 _price) external;
}
contract BitGuildHelper is Ownable {
//data contract
CardsInterface public cards ;
GameConfigInterface public schema;
RareInterface public rare;
function setCardsAddress(address _address) external onlyOwner {
}
//normal cards
function setConfigAddress(address _address) external onlyOwner {
}
//rare cards
function setRareAddress(address _address) external onlyOwner {
}
/// add multiplier
function upgradeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
}
/// move multipliers
function removeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
}
}
interface BitGuildTokenInterface { // implements ERC20Interface
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
/// @notice Purchase on BitGuild
contract BitGuildTrade is BitGuildHelper {
BitGuildTokenInterface public tokenContract;
event UnitBought(address player, uint256 unitId, uint256 amount);
event UpgradeCardBought(address player, uint256 upgradeId);
event BuyRareCard(address player, address previous, uint256 rareId,uint256 iPrice);
event UnitSold(address player, uint256 unitId, uint256 amount);
mapping(address => mapping(uint256 => uint256)) unitsOwnedOfPLAT; //cards bought through plat
function() external payable {
}
function setBitGuildToken(address _tokenContract) external {
}
function kill() public onlyOwner {
}
/// @notice Returns all the relevant information about a specific tokenId.
/// val1:flag,val2:id,val3:amount
function _getExtraParam(bytes _extraData) private pure returns(uint256 val1,uint256 val2,uint256 val3) {
}
function receiveApproval(address _player, uint256 _value, address _tokenContractAddr, bytes _extraData) external {
}
function buyPLATCards(address _player, uint256 _platValue, uint256 _cardId, uint256 _amount) internal {
}
/// upgrade cards-- jade + plat
function buyUpgradeCard(address _player, uint256 _platValue,uint256 _upgradeId) internal {
}
// Allows someone to send ether and obtain the token
function buyRareItem(address _player, uint256 _platValue,uint256 _rareId) internal {
}
/// refunds 75% since no transfer between bitguild and player,no need to call approveAndCall
function sellCards( uint256 _unitId, uint256 _amount) external {
require(cards.getGameStarted());
uint256 existing = cards.getOwnedCount(msg.sender,_unitId);
require(existing >= _amount && _amount>0);
existing = SafeMath.sub(existing,_amount);
uint256 coinChange;
uint256 decreaseCoin;
uint256 schemaUnitId;
uint256 coinProduction;
uint256 coinCost;
uint256 ethCost;
bool sellable;
if (_unitId>=40) { // upgrade card
(schemaUnitId,coinCost,, sellable) = schema.getBattleCardInfo(_unitId, existing, _amount);
ethCost = SafeMath.mul(schema.unitBattlePLATCost(_unitId),_amount);
} else {
(schemaUnitId, coinProduction, coinCost, , sellable) = schema.getCardInfo(_unitId, existing, _amount);
ethCost = SafeMath.mul(schema.unitPLATCost(_unitId),_amount); // plat
}
require(sellable); // can be refunded
if (ethCost>0) {
require(<FILL_ME>)
}
if (coinCost>0) {
coinChange = SafeMath.add(cards.balanceOfUnclaimed(msg.sender), SafeMath.div(SafeMath.mul(coinCost,70),100)); // Claim unsaved goo whilst here
} else {
coinChange = cards.balanceOfUnclaimed(msg.sender);
}
cards.setLastJadeSaveTime(msg.sender);
cards.setRoughSupply(coinChange);
cards.setJadeCoin(msg.sender, coinChange, true); // refund 75% Jadecoin to player
decreaseCoin = cards.getUnitsInProduction(msg.sender, _unitId, _amount);
if (coinProduction > 0) {
cards.reducePlayersJadeProduction(msg.sender, decreaseCoin);
//update the speed of jade minning
cards.setUintCoinProduction(msg.sender,_unitId,decreaseCoin,false);
}
if (ethCost > 0) { // Premium units sell for 75% of buy cost
cards.setCoinBalance(msg.sender,SafeMath.div(SafeMath.mul(ethCost,70),100),1,true);
}
cards.setOwnedCount(msg.sender,_unitId,_amount,false);
cards.setUintsOwnerCount(msg.sender,_amount,false);
if (ethCost>0) {
unitsOwnedOfPLAT[msg.sender][_unitId] = SafeMath.sub(unitsOwnedOfPLAT[msg.sender][_unitId],_amount);
}
//tell the world
UnitSold(msg.sender, _unitId, _amount);
}
//@notice for player withdraw
function withdrawEtherFromTrade(uint256 amount) external {
}
//@notice withraw all PLAT by dev
function withdrawToken(uint256 amount) external onlyOwner {
}
function getCanSellUnit(address _address, uint256 unitId) external view returns (uint256) {
}
}
| unitsOwnedOfPLAT[msg.sender][_unitId]>=_amount | 398,149 | unitsOwnedOfPLAT[msg.sender][_unitId]>=_amount |
"Exceeded giveaway" | // contracts/MathFlowers.sol
pragma solidity ^0.7.0;
contract MathFlowers is ERC721, Ownable {
// TR
// Once all MathFlowers are minted, we will add the hash across all MathFlowers here
string public METADATA_PROVENANCE_HASH = "";
mapping (uint256 => string) private _tokenName;
uint public constant MAX_MathFlowers = 10000;
uint public currentPrice = 80000000000000000;
bool public hasSaleStarted = false;
using SafeMath for uint256;
constructor() ERC721("MathFlowers","MathFlowers") {}
function startSale() public onlyOwner {
}
function setPrice(uint price) public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function reserveMathFlowers(uint256 numMathFlowers) public onlyOwner {
uint currentSupply = totalSupply();
// Max 42 MathFlowers for Giveaways
require(<FILL_ME>)
uint256 index;
for (index = 0; index < numMathFlowers; index++) {
_safeMint(owner(), currentSupply + index);
}
}
function calculatePrice() public view returns (uint256) {
}
function claimMathFlowers(uint256 numMathFlowers) public payable {
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
}
function tokenNameByIndex(uint256 index) public view returns (string memory) {
}
function changeName(uint256 tokenId, string memory newName) external {
}
function checkName(string memory str) public pure returns (bool){
}
}
| totalSupply().add(numMathFlowers)<=42,"Exceeded giveaway" | 398,171 | totalSupply().add(numMathFlowers)<=42 |
"Sale has already ended" | // contracts/MathFlowers.sol
pragma solidity ^0.7.0;
contract MathFlowers is ERC721, Ownable {
// TR
// Once all MathFlowers are minted, we will add the hash across all MathFlowers here
string public METADATA_PROVENANCE_HASH = "";
mapping (uint256 => string) private _tokenName;
uint public constant MAX_MathFlowers = 10000;
uint public currentPrice = 80000000000000000;
bool public hasSaleStarted = false;
using SafeMath for uint256;
constructor() ERC721("MathFlowers","MathFlowers") {}
function startSale() public onlyOwner {
}
function setPrice(uint price) public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function reserveMathFlowers(uint256 numMathFlowers) public onlyOwner {
}
function calculatePrice() public view returns (uint256) {
require(hasSaleStarted == true, "Sale hasn't started");
require(<FILL_ME>)
return currentPrice;
}
function claimMathFlowers(uint256 numMathFlowers) public payable {
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
}
function tokenNameByIndex(uint256 index) public view returns (string memory) {
}
function changeName(uint256 tokenId, string memory newName) external {
}
function checkName(string memory str) public pure returns (bool){
}
}
| totalSupply()<MAX_MathFlowers,"Sale has already ended" | 398,171 | totalSupply()<MAX_MathFlowers |
"Exceeds MAX_MathFlowers" | // contracts/MathFlowers.sol
pragma solidity ^0.7.0;
contract MathFlowers is ERC721, Ownable {
// TR
// Once all MathFlowers are minted, we will add the hash across all MathFlowers here
string public METADATA_PROVENANCE_HASH = "";
mapping (uint256 => string) private _tokenName;
uint public constant MAX_MathFlowers = 10000;
uint public currentPrice = 80000000000000000;
bool public hasSaleStarted = false;
using SafeMath for uint256;
constructor() ERC721("MathFlowers","MathFlowers") {}
function startSale() public onlyOwner {
}
function setPrice(uint price) public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function reserveMathFlowers(uint256 numMathFlowers) public onlyOwner {
}
function calculatePrice() public view returns (uint256) {
}
function claimMathFlowers(uint256 numMathFlowers) public payable {
// JJT
require(totalSupply() < MAX_MathFlowers, "Sale has already ended");
require(numMathFlowers > 0, "You have to get min 1 MathFlower");
require(<FILL_ME>)
require(msg.value >= calculatePrice().mul(numMathFlowers), "Ether value sent is below price");
for (uint i = 0; i < numMathFlowers; i++) {
uint mintIndex = totalSupply();
_safeMint(msg.sender, mintIndex);
}
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
}
function tokenNameByIndex(uint256 index) public view returns (string memory) {
}
function changeName(uint256 tokenId, string memory newName) external {
}
function checkName(string memory str) public pure returns (bool){
}
}
| totalSupply().add(numMathFlowers)<=MAX_MathFlowers,"Exceeds MAX_MathFlowers" | 398,171 | totalSupply().add(numMathFlowers)<=MAX_MathFlowers |
"ERROR: name does not follow rules" | // contracts/MathFlowers.sol
pragma solidity ^0.7.0;
contract MathFlowers is ERC721, Ownable {
// TR
// Once all MathFlowers are minted, we will add the hash across all MathFlowers here
string public METADATA_PROVENANCE_HASH = "";
mapping (uint256 => string) private _tokenName;
uint public constant MAX_MathFlowers = 10000;
uint public currentPrice = 80000000000000000;
bool public hasSaleStarted = false;
using SafeMath for uint256;
constructor() ERC721("MathFlowers","MathFlowers") {}
function startSale() public onlyOwner {
}
function setPrice(uint price) public onlyOwner {
}
function pauseSale() public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setProvenanceHash(string memory _hash) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function reserveMathFlowers(uint256 numMathFlowers) public onlyOwner {
}
function calculatePrice() public view returns (uint256) {
}
function claimMathFlowers(uint256 numMathFlowers) public payable {
}
function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
}
function tokenNameByIndex(uint256 index) public view returns (string memory) {
}
function changeName(uint256 tokenId, string memory newName) external {
require(_msgSender() == ownerOf(tokenId), "ERC721: caller is not the owner");
require(<FILL_ME>)
_tokenName[tokenId] = newName;
}
function checkName(string memory str) public pure returns (bool){
}
}
| checkName(newName)==true,"ERROR: name does not follow rules" | 398,171 | checkName(newName)==true |
"wl minting is paused" | // Wolfpack Labs LLC
// Authors: Jimmyisabot, Charmer
pragma solidity 0.8.12;
contract Hungry_Runtz is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
struct SaleState {
/// The starting mint (supply) index for the sale.
uint32 startSupply;
/// The number of mints allowed in this sale series.
uint32 seriesSize;
/// The number of tokens minted in this series. This is reset when the series is reset or rolled.
uint32 seriesSupply;
/// The lifetime total supply for this sale (never resets).
uint32 totalSupply;
/// The limit of tokens to be minted in a single transaction.
uint8 maxMint;
/// The current index of the hundreds unit being minted.
uint16 hundreds;
/// The offset of the end of the available (and pre-shuffled) list of remaining ID's for the current hundreds index.
uint8 offset;
/// If true, this sale is currently paused.
bool paused;
/// If true, reward minting is paused for this sale.
bool wlPaused;
/// A shuffled list of IDs for the current block of a hundred tokens being minted.
uint8[100] list;
}
struct AppState {
uint128 cost;
uint128 count;
uint256 nonce;
}
SaleState _free =
SaleState(
0,
30000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[100, 99, 9, 84, 45, 23, 86, 17, 36, 64, 55, 29, 79, 58, 27, 25, 95, 3, 66, 40, 82, 87, 88, 42, 35, 12, 15, 1, 96, 89, 73, 6, 61, 57, 43, 56, 4, 90, 28, 91, 72, 68, 44, 38, 77, 65, 2, 71, 75, 94, 76, 7, 16, 34, 83, 98, 10, 33, 63, 62, 78, 49, 92, 24, 54, 8, 30, 52, 74, 21, 11, 51, 5, 70, 32, 37, 67, 13, 69, 53, 50, 41, 14, 22, 31, 85, 46, 80, 26, 93, 48, 47, 39, 97, 59, 20, 19, 81, 60, 18]
);
SaleState _paid =
SaleState(
50000,
10000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[64, 26, 33, 81, 16, 41, 82, 55, 95, 2, 18, 20, 5, 84, 93, 21, 53, 94, 96, 73, 34, 11, 78, 98, 51, 30, 17, 68, 14, 92, 86, 75, 58, 31, 69, 36, 27, 4, 44, 63, 42, 35, 7, 47, 37, 65, 87, 100, 74, 61, 28, 24, 49, 13, 54, 12, 8, 29, 80, 83, 38, 43, 70, 85, 66, 45, 10, 22, 46, 77, 56, 76, 48, 71, 60, 89, 15, 97, 40, 67, 39, 52, 91, 79, 25, 1, 6, 62, 32, 19, 59, 23, 9, 3, 90, 57, 72, 99, 88, 50]
);
AppState _state = AppState(0.005 ether, 0, uint256(blockhash(block.number)) ^ uint256(block.timestamp));
string public baseURI;
string public baseExtension = ".json";
address[] freeWL;
address[] paidWL;
event ExternalContractFailure(address extContract, bytes error);
constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {}
function freeWLMint(uint256 mintAmount) external payable nonReentrant isHolder(freeWL) {
require(<FILL_ME>)
require(mintAmount <= _free.maxMint, "sale: exceeded max mint amount");
require(_free.seriesSupply + mintAmount <= _free.seriesSize, "sale: not enough supply left");
_doMint(mintAmount, _free);
}
function paidWLMint(uint256 mintAmount) external payable nonReentrant isHolder(paidWL) {
}
function paidMint(uint256 _mintAmount) external payable nonReentrant withValidMint(_paid, _mintAmount) {
}
function freeMint(uint256 mintAmount) external payable nonReentrant withValidMint(_free, mintAmount) {
}
function _doMint(uint256 _mintAmount, SaleState storage sale) internal {
}
modifier isHolder(address[] memory wl) {
}
modifier withValidMint(SaleState memory sale, uint256 mintAmount) {
}
function nextNonce(uint256 previousNonce, uint256 counter) internal view returns (uint256 nonce) {
}
function randMod(uint256 modulus) internal view returns (uint256 rand) {
}
function walletOfOwner(address owner) public view returns (uint256[] memory) {
}
// Free Mint Functions
function setFreeMaxMint(uint8 freeMaxMint) external onlyOwner {
}
function setFreeStart(uint32 supply) external onlyOwner {
}
function setFreeOffset(uint8 idx) external onlyOwner {
}
function setFreeHundredsIndex(uint16 idx) external onlyOwner {
}
function freeMintPause(bool paused) external onlyOwner {
}
function setFreeSeriesSupply(uint32 supply) external onlyOwner {
}
function setFreeSeriesSize(uint32 freeSize) external onlyOwner {
}
function setFreeWL(address[] calldata contracts) external onlyOwner {
}
function pauseFreeWL(bool paused) external onlyOwner {
}
function getFreeState() external view onlyOwner returns (SaleState memory _freeState) {
}
function getPaidState() external view onlyOwner returns (SaleState memory) {
}
// Paid Mint Functions
function setPaidCost(uint128 cost) external onlyOwner {
}
function setPaidMaxMint(uint8 paidMaxMint) external onlyOwner {
}
function setPaidStart(uint32 supply) external onlyOwner {
}
function setPaidOffset(uint8 idx) external onlyOwner {
}
function setPaidHundredsIndex(uint16 idx) external onlyOwner {
}
function paidMintPause(bool state) external onlyOwner {
}
function setPaidSeriesSupply(uint32 supply) external onlyOwner {
}
function setPaidSeriesSize(uint32 size) external onlyOwner {
}
function setPaidWL(address[] calldata contracts) external onlyOwner {
}
function pausePaidWL(bool paused) external onlyOwner {
}
// Contract-Wide Functions
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBaseExtension(string memory ext) external onlyOwner {
}
function burnToken(uint256 tokenId) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !_free.wlPaused,"wl minting is paused" | 398,294 | !_free.wlPaused |
"sale: not enough supply left" | // Wolfpack Labs LLC
// Authors: Jimmyisabot, Charmer
pragma solidity 0.8.12;
contract Hungry_Runtz is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
struct SaleState {
/// The starting mint (supply) index for the sale.
uint32 startSupply;
/// The number of mints allowed in this sale series.
uint32 seriesSize;
/// The number of tokens minted in this series. This is reset when the series is reset or rolled.
uint32 seriesSupply;
/// The lifetime total supply for this sale (never resets).
uint32 totalSupply;
/// The limit of tokens to be minted in a single transaction.
uint8 maxMint;
/// The current index of the hundreds unit being minted.
uint16 hundreds;
/// The offset of the end of the available (and pre-shuffled) list of remaining ID's for the current hundreds index.
uint8 offset;
/// If true, this sale is currently paused.
bool paused;
/// If true, reward minting is paused for this sale.
bool wlPaused;
/// A shuffled list of IDs for the current block of a hundred tokens being minted.
uint8[100] list;
}
struct AppState {
uint128 cost;
uint128 count;
uint256 nonce;
}
SaleState _free =
SaleState(
0,
30000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[100, 99, 9, 84, 45, 23, 86, 17, 36, 64, 55, 29, 79, 58, 27, 25, 95, 3, 66, 40, 82, 87, 88, 42, 35, 12, 15, 1, 96, 89, 73, 6, 61, 57, 43, 56, 4, 90, 28, 91, 72, 68, 44, 38, 77, 65, 2, 71, 75, 94, 76, 7, 16, 34, 83, 98, 10, 33, 63, 62, 78, 49, 92, 24, 54, 8, 30, 52, 74, 21, 11, 51, 5, 70, 32, 37, 67, 13, 69, 53, 50, 41, 14, 22, 31, 85, 46, 80, 26, 93, 48, 47, 39, 97, 59, 20, 19, 81, 60, 18]
);
SaleState _paid =
SaleState(
50000,
10000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[64, 26, 33, 81, 16, 41, 82, 55, 95, 2, 18, 20, 5, 84, 93, 21, 53, 94, 96, 73, 34, 11, 78, 98, 51, 30, 17, 68, 14, 92, 86, 75, 58, 31, 69, 36, 27, 4, 44, 63, 42, 35, 7, 47, 37, 65, 87, 100, 74, 61, 28, 24, 49, 13, 54, 12, 8, 29, 80, 83, 38, 43, 70, 85, 66, 45, 10, 22, 46, 77, 56, 76, 48, 71, 60, 89, 15, 97, 40, 67, 39, 52, 91, 79, 25, 1, 6, 62, 32, 19, 59, 23, 9, 3, 90, 57, 72, 99, 88, 50]
);
AppState _state = AppState(0.005 ether, 0, uint256(blockhash(block.number)) ^ uint256(block.timestamp));
string public baseURI;
string public baseExtension = ".json";
address[] freeWL;
address[] paidWL;
event ExternalContractFailure(address extContract, bytes error);
constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {}
function freeWLMint(uint256 mintAmount) external payable nonReentrant isHolder(freeWL) {
require(!_free.wlPaused, "wl minting is paused");
require(mintAmount <= _free.maxMint, "sale: exceeded max mint amount");
require(<FILL_ME>)
_doMint(mintAmount, _free);
}
function paidWLMint(uint256 mintAmount) external payable nonReentrant isHolder(paidWL) {
}
function paidMint(uint256 _mintAmount) external payable nonReentrant withValidMint(_paid, _mintAmount) {
}
function freeMint(uint256 mintAmount) external payable nonReentrant withValidMint(_free, mintAmount) {
}
function _doMint(uint256 _mintAmount, SaleState storage sale) internal {
}
modifier isHolder(address[] memory wl) {
}
modifier withValidMint(SaleState memory sale, uint256 mintAmount) {
}
function nextNonce(uint256 previousNonce, uint256 counter) internal view returns (uint256 nonce) {
}
function randMod(uint256 modulus) internal view returns (uint256 rand) {
}
function walletOfOwner(address owner) public view returns (uint256[] memory) {
}
// Free Mint Functions
function setFreeMaxMint(uint8 freeMaxMint) external onlyOwner {
}
function setFreeStart(uint32 supply) external onlyOwner {
}
function setFreeOffset(uint8 idx) external onlyOwner {
}
function setFreeHundredsIndex(uint16 idx) external onlyOwner {
}
function freeMintPause(bool paused) external onlyOwner {
}
function setFreeSeriesSupply(uint32 supply) external onlyOwner {
}
function setFreeSeriesSize(uint32 freeSize) external onlyOwner {
}
function setFreeWL(address[] calldata contracts) external onlyOwner {
}
function pauseFreeWL(bool paused) external onlyOwner {
}
function getFreeState() external view onlyOwner returns (SaleState memory _freeState) {
}
function getPaidState() external view onlyOwner returns (SaleState memory) {
}
// Paid Mint Functions
function setPaidCost(uint128 cost) external onlyOwner {
}
function setPaidMaxMint(uint8 paidMaxMint) external onlyOwner {
}
function setPaidStart(uint32 supply) external onlyOwner {
}
function setPaidOffset(uint8 idx) external onlyOwner {
}
function setPaidHundredsIndex(uint16 idx) external onlyOwner {
}
function paidMintPause(bool state) external onlyOwner {
}
function setPaidSeriesSupply(uint32 supply) external onlyOwner {
}
function setPaidSeriesSize(uint32 size) external onlyOwner {
}
function setPaidWL(address[] calldata contracts) external onlyOwner {
}
function pausePaidWL(bool paused) external onlyOwner {
}
// Contract-Wide Functions
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBaseExtension(string memory ext) external onlyOwner {
}
function burnToken(uint256 tokenId) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _free.seriesSupply+mintAmount<=_free.seriesSize,"sale: not enough supply left" | 398,294 | _free.seriesSupply+mintAmount<=_free.seriesSize |
"wl minting is paused" | // Wolfpack Labs LLC
// Authors: Jimmyisabot, Charmer
pragma solidity 0.8.12;
contract Hungry_Runtz is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
struct SaleState {
/// The starting mint (supply) index for the sale.
uint32 startSupply;
/// The number of mints allowed in this sale series.
uint32 seriesSize;
/// The number of tokens minted in this series. This is reset when the series is reset or rolled.
uint32 seriesSupply;
/// The lifetime total supply for this sale (never resets).
uint32 totalSupply;
/// The limit of tokens to be minted in a single transaction.
uint8 maxMint;
/// The current index of the hundreds unit being minted.
uint16 hundreds;
/// The offset of the end of the available (and pre-shuffled) list of remaining ID's for the current hundreds index.
uint8 offset;
/// If true, this sale is currently paused.
bool paused;
/// If true, reward minting is paused for this sale.
bool wlPaused;
/// A shuffled list of IDs for the current block of a hundred tokens being minted.
uint8[100] list;
}
struct AppState {
uint128 cost;
uint128 count;
uint256 nonce;
}
SaleState _free =
SaleState(
0,
30000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[100, 99, 9, 84, 45, 23, 86, 17, 36, 64, 55, 29, 79, 58, 27, 25, 95, 3, 66, 40, 82, 87, 88, 42, 35, 12, 15, 1, 96, 89, 73, 6, 61, 57, 43, 56, 4, 90, 28, 91, 72, 68, 44, 38, 77, 65, 2, 71, 75, 94, 76, 7, 16, 34, 83, 98, 10, 33, 63, 62, 78, 49, 92, 24, 54, 8, 30, 52, 74, 21, 11, 51, 5, 70, 32, 37, 67, 13, 69, 53, 50, 41, 14, 22, 31, 85, 46, 80, 26, 93, 48, 47, 39, 97, 59, 20, 19, 81, 60, 18]
);
SaleState _paid =
SaleState(
50000,
10000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[64, 26, 33, 81, 16, 41, 82, 55, 95, 2, 18, 20, 5, 84, 93, 21, 53, 94, 96, 73, 34, 11, 78, 98, 51, 30, 17, 68, 14, 92, 86, 75, 58, 31, 69, 36, 27, 4, 44, 63, 42, 35, 7, 47, 37, 65, 87, 100, 74, 61, 28, 24, 49, 13, 54, 12, 8, 29, 80, 83, 38, 43, 70, 85, 66, 45, 10, 22, 46, 77, 56, 76, 48, 71, 60, 89, 15, 97, 40, 67, 39, 52, 91, 79, 25, 1, 6, 62, 32, 19, 59, 23, 9, 3, 90, 57, 72, 99, 88, 50]
);
AppState _state = AppState(0.005 ether, 0, uint256(blockhash(block.number)) ^ uint256(block.timestamp));
string public baseURI;
string public baseExtension = ".json";
address[] freeWL;
address[] paidWL;
event ExternalContractFailure(address extContract, bytes error);
constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {}
function freeWLMint(uint256 mintAmount) external payable nonReentrant isHolder(freeWL) {
}
function paidWLMint(uint256 mintAmount) external payable nonReentrant isHolder(paidWL) {
require(<FILL_ME>)
require(mintAmount <= _paid.maxMint, "sale: exceeded max mint amount");
require(_paid.seriesSupply + mintAmount <= _paid.seriesSize, "sale: not enough supply left");
require(msg.value >= _state.cost * mintAmount);
_doMint(mintAmount, _paid);
}
function paidMint(uint256 _mintAmount) external payable nonReentrant withValidMint(_paid, _mintAmount) {
}
function freeMint(uint256 mintAmount) external payable nonReentrant withValidMint(_free, mintAmount) {
}
function _doMint(uint256 _mintAmount, SaleState storage sale) internal {
}
modifier isHolder(address[] memory wl) {
}
modifier withValidMint(SaleState memory sale, uint256 mintAmount) {
}
function nextNonce(uint256 previousNonce, uint256 counter) internal view returns (uint256 nonce) {
}
function randMod(uint256 modulus) internal view returns (uint256 rand) {
}
function walletOfOwner(address owner) public view returns (uint256[] memory) {
}
// Free Mint Functions
function setFreeMaxMint(uint8 freeMaxMint) external onlyOwner {
}
function setFreeStart(uint32 supply) external onlyOwner {
}
function setFreeOffset(uint8 idx) external onlyOwner {
}
function setFreeHundredsIndex(uint16 idx) external onlyOwner {
}
function freeMintPause(bool paused) external onlyOwner {
}
function setFreeSeriesSupply(uint32 supply) external onlyOwner {
}
function setFreeSeriesSize(uint32 freeSize) external onlyOwner {
}
function setFreeWL(address[] calldata contracts) external onlyOwner {
}
function pauseFreeWL(bool paused) external onlyOwner {
}
function getFreeState() external view onlyOwner returns (SaleState memory _freeState) {
}
function getPaidState() external view onlyOwner returns (SaleState memory) {
}
// Paid Mint Functions
function setPaidCost(uint128 cost) external onlyOwner {
}
function setPaidMaxMint(uint8 paidMaxMint) external onlyOwner {
}
function setPaidStart(uint32 supply) external onlyOwner {
}
function setPaidOffset(uint8 idx) external onlyOwner {
}
function setPaidHundredsIndex(uint16 idx) external onlyOwner {
}
function paidMintPause(bool state) external onlyOwner {
}
function setPaidSeriesSupply(uint32 supply) external onlyOwner {
}
function setPaidSeriesSize(uint32 size) external onlyOwner {
}
function setPaidWL(address[] calldata contracts) external onlyOwner {
}
function pausePaidWL(bool paused) external onlyOwner {
}
// Contract-Wide Functions
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBaseExtension(string memory ext) external onlyOwner {
}
function burnToken(uint256 tokenId) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !_paid.wlPaused,"wl minting is paused" | 398,294 | !_paid.wlPaused |
"sale: not enough supply left" | // Wolfpack Labs LLC
// Authors: Jimmyisabot, Charmer
pragma solidity 0.8.12;
contract Hungry_Runtz is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
struct SaleState {
/// The starting mint (supply) index for the sale.
uint32 startSupply;
/// The number of mints allowed in this sale series.
uint32 seriesSize;
/// The number of tokens minted in this series. This is reset when the series is reset or rolled.
uint32 seriesSupply;
/// The lifetime total supply for this sale (never resets).
uint32 totalSupply;
/// The limit of tokens to be minted in a single transaction.
uint8 maxMint;
/// The current index of the hundreds unit being minted.
uint16 hundreds;
/// The offset of the end of the available (and pre-shuffled) list of remaining ID's for the current hundreds index.
uint8 offset;
/// If true, this sale is currently paused.
bool paused;
/// If true, reward minting is paused for this sale.
bool wlPaused;
/// A shuffled list of IDs for the current block of a hundred tokens being minted.
uint8[100] list;
}
struct AppState {
uint128 cost;
uint128 count;
uint256 nonce;
}
SaleState _free =
SaleState(
0,
30000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[100, 99, 9, 84, 45, 23, 86, 17, 36, 64, 55, 29, 79, 58, 27, 25, 95, 3, 66, 40, 82, 87, 88, 42, 35, 12, 15, 1, 96, 89, 73, 6, 61, 57, 43, 56, 4, 90, 28, 91, 72, 68, 44, 38, 77, 65, 2, 71, 75, 94, 76, 7, 16, 34, 83, 98, 10, 33, 63, 62, 78, 49, 92, 24, 54, 8, 30, 52, 74, 21, 11, 51, 5, 70, 32, 37, 67, 13, 69, 53, 50, 41, 14, 22, 31, 85, 46, 80, 26, 93, 48, 47, 39, 97, 59, 20, 19, 81, 60, 18]
);
SaleState _paid =
SaleState(
50000,
10000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[64, 26, 33, 81, 16, 41, 82, 55, 95, 2, 18, 20, 5, 84, 93, 21, 53, 94, 96, 73, 34, 11, 78, 98, 51, 30, 17, 68, 14, 92, 86, 75, 58, 31, 69, 36, 27, 4, 44, 63, 42, 35, 7, 47, 37, 65, 87, 100, 74, 61, 28, 24, 49, 13, 54, 12, 8, 29, 80, 83, 38, 43, 70, 85, 66, 45, 10, 22, 46, 77, 56, 76, 48, 71, 60, 89, 15, 97, 40, 67, 39, 52, 91, 79, 25, 1, 6, 62, 32, 19, 59, 23, 9, 3, 90, 57, 72, 99, 88, 50]
);
AppState _state = AppState(0.005 ether, 0, uint256(blockhash(block.number)) ^ uint256(block.timestamp));
string public baseURI;
string public baseExtension = ".json";
address[] freeWL;
address[] paidWL;
event ExternalContractFailure(address extContract, bytes error);
constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {}
function freeWLMint(uint256 mintAmount) external payable nonReentrant isHolder(freeWL) {
}
function paidWLMint(uint256 mintAmount) external payable nonReentrant isHolder(paidWL) {
require(!_paid.wlPaused, "wl minting is paused");
require(mintAmount <= _paid.maxMint, "sale: exceeded max mint amount");
require(<FILL_ME>)
require(msg.value >= _state.cost * mintAmount);
_doMint(mintAmount, _paid);
}
function paidMint(uint256 _mintAmount) external payable nonReentrant withValidMint(_paid, _mintAmount) {
}
function freeMint(uint256 mintAmount) external payable nonReentrant withValidMint(_free, mintAmount) {
}
function _doMint(uint256 _mintAmount, SaleState storage sale) internal {
}
modifier isHolder(address[] memory wl) {
}
modifier withValidMint(SaleState memory sale, uint256 mintAmount) {
}
function nextNonce(uint256 previousNonce, uint256 counter) internal view returns (uint256 nonce) {
}
function randMod(uint256 modulus) internal view returns (uint256 rand) {
}
function walletOfOwner(address owner) public view returns (uint256[] memory) {
}
// Free Mint Functions
function setFreeMaxMint(uint8 freeMaxMint) external onlyOwner {
}
function setFreeStart(uint32 supply) external onlyOwner {
}
function setFreeOffset(uint8 idx) external onlyOwner {
}
function setFreeHundredsIndex(uint16 idx) external onlyOwner {
}
function freeMintPause(bool paused) external onlyOwner {
}
function setFreeSeriesSupply(uint32 supply) external onlyOwner {
}
function setFreeSeriesSize(uint32 freeSize) external onlyOwner {
}
function setFreeWL(address[] calldata contracts) external onlyOwner {
}
function pauseFreeWL(bool paused) external onlyOwner {
}
function getFreeState() external view onlyOwner returns (SaleState memory _freeState) {
}
function getPaidState() external view onlyOwner returns (SaleState memory) {
}
// Paid Mint Functions
function setPaidCost(uint128 cost) external onlyOwner {
}
function setPaidMaxMint(uint8 paidMaxMint) external onlyOwner {
}
function setPaidStart(uint32 supply) external onlyOwner {
}
function setPaidOffset(uint8 idx) external onlyOwner {
}
function setPaidHundredsIndex(uint16 idx) external onlyOwner {
}
function paidMintPause(bool state) external onlyOwner {
}
function setPaidSeriesSupply(uint32 supply) external onlyOwner {
}
function setPaidSeriesSize(uint32 size) external onlyOwner {
}
function setPaidWL(address[] calldata contracts) external onlyOwner {
}
function pausePaidWL(bool paused) external onlyOwner {
}
// Contract-Wide Functions
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBaseExtension(string memory ext) external onlyOwner {
}
function burnToken(uint256 tokenId) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| _paid.seriesSupply+mintAmount<=_paid.seriesSize,"sale: not enough supply left" | 398,294 | _paid.seriesSupply+mintAmount<=_paid.seriesSize |
"sale: not active" | // Wolfpack Labs LLC
// Authors: Jimmyisabot, Charmer
pragma solidity 0.8.12;
contract Hungry_Runtz is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
struct SaleState {
/// The starting mint (supply) index for the sale.
uint32 startSupply;
/// The number of mints allowed in this sale series.
uint32 seriesSize;
/// The number of tokens minted in this series. This is reset when the series is reset or rolled.
uint32 seriesSupply;
/// The lifetime total supply for this sale (never resets).
uint32 totalSupply;
/// The limit of tokens to be minted in a single transaction.
uint8 maxMint;
/// The current index of the hundreds unit being minted.
uint16 hundreds;
/// The offset of the end of the available (and pre-shuffled) list of remaining ID's for the current hundreds index.
uint8 offset;
/// If true, this sale is currently paused.
bool paused;
/// If true, reward minting is paused for this sale.
bool wlPaused;
/// A shuffled list of IDs for the current block of a hundred tokens being minted.
uint8[100] list;
}
struct AppState {
uint128 cost;
uint128 count;
uint256 nonce;
}
SaleState _free =
SaleState(
0,
30000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[100, 99, 9, 84, 45, 23, 86, 17, 36, 64, 55, 29, 79, 58, 27, 25, 95, 3, 66, 40, 82, 87, 88, 42, 35, 12, 15, 1, 96, 89, 73, 6, 61, 57, 43, 56, 4, 90, 28, 91, 72, 68, 44, 38, 77, 65, 2, 71, 75, 94, 76, 7, 16, 34, 83, 98, 10, 33, 63, 62, 78, 49, 92, 24, 54, 8, 30, 52, 74, 21, 11, 51, 5, 70, 32, 37, 67, 13, 69, 53, 50, 41, 14, 22, 31, 85, 46, 80, 26, 93, 48, 47, 39, 97, 59, 20, 19, 81, 60, 18]
);
SaleState _paid =
SaleState(
50000,
10000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[64, 26, 33, 81, 16, 41, 82, 55, 95, 2, 18, 20, 5, 84, 93, 21, 53, 94, 96, 73, 34, 11, 78, 98, 51, 30, 17, 68, 14, 92, 86, 75, 58, 31, 69, 36, 27, 4, 44, 63, 42, 35, 7, 47, 37, 65, 87, 100, 74, 61, 28, 24, 49, 13, 54, 12, 8, 29, 80, 83, 38, 43, 70, 85, 66, 45, 10, 22, 46, 77, 56, 76, 48, 71, 60, 89, 15, 97, 40, 67, 39, 52, 91, 79, 25, 1, 6, 62, 32, 19, 59, 23, 9, 3, 90, 57, 72, 99, 88, 50]
);
AppState _state = AppState(0.005 ether, 0, uint256(blockhash(block.number)) ^ uint256(block.timestamp));
string public baseURI;
string public baseExtension = ".json";
address[] freeWL;
address[] paidWL;
event ExternalContractFailure(address extContract, bytes error);
constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {}
function freeWLMint(uint256 mintAmount) external payable nonReentrant isHolder(freeWL) {
}
function paidWLMint(uint256 mintAmount) external payable nonReentrant isHolder(paidWL) {
}
function paidMint(uint256 _mintAmount) external payable nonReentrant withValidMint(_paid, _mintAmount) {
}
function freeMint(uint256 mintAmount) external payable nonReentrant withValidMint(_free, mintAmount) {
}
function _doMint(uint256 _mintAmount, SaleState storage sale) internal {
}
modifier isHolder(address[] memory wl) {
}
modifier withValidMint(SaleState memory sale, uint256 mintAmount) {
require(<FILL_ME>)
require(mintAmount <= sale.maxMint, "sale: exceeded max mint amount");
require(sale.seriesSupply + mintAmount <= sale.seriesSize, "sale: not enough supply left");
_;
}
function nextNonce(uint256 previousNonce, uint256 counter) internal view returns (uint256 nonce) {
}
function randMod(uint256 modulus) internal view returns (uint256 rand) {
}
function walletOfOwner(address owner) public view returns (uint256[] memory) {
}
// Free Mint Functions
function setFreeMaxMint(uint8 freeMaxMint) external onlyOwner {
}
function setFreeStart(uint32 supply) external onlyOwner {
}
function setFreeOffset(uint8 idx) external onlyOwner {
}
function setFreeHundredsIndex(uint16 idx) external onlyOwner {
}
function freeMintPause(bool paused) external onlyOwner {
}
function setFreeSeriesSupply(uint32 supply) external onlyOwner {
}
function setFreeSeriesSize(uint32 freeSize) external onlyOwner {
}
function setFreeWL(address[] calldata contracts) external onlyOwner {
}
function pauseFreeWL(bool paused) external onlyOwner {
}
function getFreeState() external view onlyOwner returns (SaleState memory _freeState) {
}
function getPaidState() external view onlyOwner returns (SaleState memory) {
}
// Paid Mint Functions
function setPaidCost(uint128 cost) external onlyOwner {
}
function setPaidMaxMint(uint8 paidMaxMint) external onlyOwner {
}
function setPaidStart(uint32 supply) external onlyOwner {
}
function setPaidOffset(uint8 idx) external onlyOwner {
}
function setPaidHundredsIndex(uint16 idx) external onlyOwner {
}
function paidMintPause(bool state) external onlyOwner {
}
function setPaidSeriesSupply(uint32 supply) external onlyOwner {
}
function setPaidSeriesSize(uint32 size) external onlyOwner {
}
function setPaidWL(address[] calldata contracts) external onlyOwner {
}
function pausePaidWL(bool paused) external onlyOwner {
}
// Contract-Wide Functions
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBaseExtension(string memory ext) external onlyOwner {
}
function burnToken(uint256 tokenId) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| !sale.paused,"sale: not active" | 398,294 | !sale.paused |
"sale: not enough supply left" | // Wolfpack Labs LLC
// Authors: Jimmyisabot, Charmer
pragma solidity 0.8.12;
contract Hungry_Runtz is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
struct SaleState {
/// The starting mint (supply) index for the sale.
uint32 startSupply;
/// The number of mints allowed in this sale series.
uint32 seriesSize;
/// The number of tokens minted in this series. This is reset when the series is reset or rolled.
uint32 seriesSupply;
/// The lifetime total supply for this sale (never resets).
uint32 totalSupply;
/// The limit of tokens to be minted in a single transaction.
uint8 maxMint;
/// The current index of the hundreds unit being minted.
uint16 hundreds;
/// The offset of the end of the available (and pre-shuffled) list of remaining ID's for the current hundreds index.
uint8 offset;
/// If true, this sale is currently paused.
bool paused;
/// If true, reward minting is paused for this sale.
bool wlPaused;
/// A shuffled list of IDs for the current block of a hundred tokens being minted.
uint8[100] list;
}
struct AppState {
uint128 cost;
uint128 count;
uint256 nonce;
}
SaleState _free =
SaleState(
0,
30000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[100, 99, 9, 84, 45, 23, 86, 17, 36, 64, 55, 29, 79, 58, 27, 25, 95, 3, 66, 40, 82, 87, 88, 42, 35, 12, 15, 1, 96, 89, 73, 6, 61, 57, 43, 56, 4, 90, 28, 91, 72, 68, 44, 38, 77, 65, 2, 71, 75, 94, 76, 7, 16, 34, 83, 98, 10, 33, 63, 62, 78, 49, 92, 24, 54, 8, 30, 52, 74, 21, 11, 51, 5, 70, 32, 37, 67, 13, 69, 53, 50, 41, 14, 22, 31, 85, 46, 80, 26, 93, 48, 47, 39, 97, 59, 20, 19, 81, 60, 18]
);
SaleState _paid =
SaleState(
50000,
10000,
0,
0,
20,
0,
99,
true,
false,
// prettier-ignore
[64, 26, 33, 81, 16, 41, 82, 55, 95, 2, 18, 20, 5, 84, 93, 21, 53, 94, 96, 73, 34, 11, 78, 98, 51, 30, 17, 68, 14, 92, 86, 75, 58, 31, 69, 36, 27, 4, 44, 63, 42, 35, 7, 47, 37, 65, 87, 100, 74, 61, 28, 24, 49, 13, 54, 12, 8, 29, 80, 83, 38, 43, 70, 85, 66, 45, 10, 22, 46, 77, 56, 76, 48, 71, 60, 89, 15, 97, 40, 67, 39, 52, 91, 79, 25, 1, 6, 62, 32, 19, 59, 23, 9, 3, 90, 57, 72, 99, 88, 50]
);
AppState _state = AppState(0.005 ether, 0, uint256(blockhash(block.number)) ^ uint256(block.timestamp));
string public baseURI;
string public baseExtension = ".json";
address[] freeWL;
address[] paidWL;
event ExternalContractFailure(address extContract, bytes error);
constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {}
function freeWLMint(uint256 mintAmount) external payable nonReentrant isHolder(freeWL) {
}
function paidWLMint(uint256 mintAmount) external payable nonReentrant isHolder(paidWL) {
}
function paidMint(uint256 _mintAmount) external payable nonReentrant withValidMint(_paid, _mintAmount) {
}
function freeMint(uint256 mintAmount) external payable nonReentrant withValidMint(_free, mintAmount) {
}
function _doMint(uint256 _mintAmount, SaleState storage sale) internal {
}
modifier isHolder(address[] memory wl) {
}
modifier withValidMint(SaleState memory sale, uint256 mintAmount) {
require(!sale.paused, "sale: not active");
require(mintAmount <= sale.maxMint, "sale: exceeded max mint amount");
require(<FILL_ME>)
_;
}
function nextNonce(uint256 previousNonce, uint256 counter) internal view returns (uint256 nonce) {
}
function randMod(uint256 modulus) internal view returns (uint256 rand) {
}
function walletOfOwner(address owner) public view returns (uint256[] memory) {
}
// Free Mint Functions
function setFreeMaxMint(uint8 freeMaxMint) external onlyOwner {
}
function setFreeStart(uint32 supply) external onlyOwner {
}
function setFreeOffset(uint8 idx) external onlyOwner {
}
function setFreeHundredsIndex(uint16 idx) external onlyOwner {
}
function freeMintPause(bool paused) external onlyOwner {
}
function setFreeSeriesSupply(uint32 supply) external onlyOwner {
}
function setFreeSeriesSize(uint32 freeSize) external onlyOwner {
}
function setFreeWL(address[] calldata contracts) external onlyOwner {
}
function pauseFreeWL(bool paused) external onlyOwner {
}
function getFreeState() external view onlyOwner returns (SaleState memory _freeState) {
}
function getPaidState() external view onlyOwner returns (SaleState memory) {
}
// Paid Mint Functions
function setPaidCost(uint128 cost) external onlyOwner {
}
function setPaidMaxMint(uint8 paidMaxMint) external onlyOwner {
}
function setPaidStart(uint32 supply) external onlyOwner {
}
function setPaidOffset(uint8 idx) external onlyOwner {
}
function setPaidHundredsIndex(uint16 idx) external onlyOwner {
}
function paidMintPause(bool state) external onlyOwner {
}
function setPaidSeriesSupply(uint32 supply) external onlyOwner {
}
function setPaidSeriesSize(uint32 size) external onlyOwner {
}
function setPaidWL(address[] calldata contracts) external onlyOwner {
}
function pausePaidWL(bool paused) external onlyOwner {
}
// Contract-Wide Functions
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function setBaseExtension(string memory ext) external onlyOwner {
}
function burnToken(uint256 tokenId) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| sale.seriesSupply+mintAmount<=sale.seriesSize,"sale: not enough supply left" | 398,294 | sale.seriesSupply+mintAmount<=sale.seriesSize |
"FLOKIIPreSale: No balance to withdraw." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
contract FLOKIIPreSale is Ownable {
using SafeERC20 for IERC20;
enum PurchaseType {
USDT,
ETH
}
IERC20 public flokii;
IERC20 public usdt;
address payable private _admin;
uint public usdtPrice; // How many Flokiies per USDT.
AggregatorV3Interface internal priceFeed;
event Purchase(uint amount, PurchaseType purchaseType, address buyer);
constructor(address argFlokii,
address argUsdt,
address payable argAdmin,
uint argUsdtPrice,
address argEthPriceFeedAddress) {
}
function purchaseByUSDT(uint argUsdtAmount) public {
}
function purchaseByETH() public payable {
}
function purchaseByETH(address argBuyer, uint argEthValue) private {
}
receive() external payable {
}
function withdraw() public onlyOwner {
uint usdtBalance = usdt.balanceOf(address(this));
uint ethBalance = address(this).balance;
require(<FILL_ME>)
if(usdtBalance > 0) {
usdt.safeTransfer(msg.sender, usdtBalance);
}
if(ethBalance > 0) {
payable(msg.sender).transfer(ethBalance);
}
}
function getEthPrice() public view returns (uint) {
}
}
| (usdtBalance>0)||(ethBalance>0),"FLOKIIPreSale: No balance to withdraw." | 398,299 | (usdtBalance>0)||(ethBalance>0) |
"Sale end" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract EliteChessClub is
ERC721Enumerable,
Ownable,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
address public _royaltiesReceiver = 0x03415648E2e38311640a6C49A8843A69504CFE30;
uint public royaltiesPercentage = 10;
uint256 public constant MAX_ELEMENTS_PRESALE = 1000;
uint256 public constant MAX_ELEMENTS_PUBLIC = 10000;
uint256 public presale_price = 5 * 10**16;
uint256 public public_price = 8 * 10**16;
address private _ownerOfContract;
bool public isPresale = true;
address[] public whitelistedAddresses;
string public baseTokenURI;
mapping(address => uint256) public addressMintedBalance;
uint256 public nftPerAddressLimit = 5;
uint256 public nftLimitPresale = 30;
event CreateElite(uint256 indexed id);
constructor() ERC721("Elite Chess Club", "ECC") {
}
function royaltiesReceiver() public view returns(address) {
}
function setRoyaltiesReceiver(address newRoyaltiesReceiver)
external onlyOwner {
}
function royaltyInfo(uint256 _salePrice) external view
returns (address receiver, uint256 royaltyAmount) {
}
// function set
modifier saleIsOpen() {
}
function _totalSupply() internal view returns (uint256) {
}
function totalMint() public view returns (uint256) {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
uint256 total = _totalSupply();
require(<FILL_ME>)
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != _ownerOfContract) {
if (isPresale) {
require(total + _count <= MAX_ELEMENTS_PRESALE, "Max limit for presale");
require(msg.value >= priceOfPresale(_count), "Value below price");
if ( isWhitelisted(msg.sender)){
require(ownerMintedCount + _count <= nftLimitPresale, "max NFT per address exceeded for whitelist");
}
else{
require(ownerMintedCount + _count <= nftPerAddressLimit, "Max NFT per address exceeded for Presale");
}
}
else{
require(total + _count <= MAX_ELEMENTS_PUBLIC, "Max limit for public");
require(msg.value >= priceOfPublic(_count), "Value below price");
}
}
for (uint256 i = 1; i <= _count; i++) {
addressMintedBalance[msg.sender]++;
_mintAnElement(_to);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function _mintAnElement(address _to) private {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function addWhitelist(address _user) public onlyOwner {
}
function priceOfPresale(uint256 _count) public view returns (uint256) {
}
function priceOfPublic(uint256 _count) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setPresale(bool _presale) public onlyOwner{
}
}
| total<=(MAX_ELEMENTS_PRESALE+MAX_ELEMENTS_PUBLIC),"Sale end" | 398,321 | total<=(MAX_ELEMENTS_PRESALE+MAX_ELEMENTS_PUBLIC) |
"Max limit for presale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract EliteChessClub is
ERC721Enumerable,
Ownable,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
address public _royaltiesReceiver = 0x03415648E2e38311640a6C49A8843A69504CFE30;
uint public royaltiesPercentage = 10;
uint256 public constant MAX_ELEMENTS_PRESALE = 1000;
uint256 public constant MAX_ELEMENTS_PUBLIC = 10000;
uint256 public presale_price = 5 * 10**16;
uint256 public public_price = 8 * 10**16;
address private _ownerOfContract;
bool public isPresale = true;
address[] public whitelistedAddresses;
string public baseTokenURI;
mapping(address => uint256) public addressMintedBalance;
uint256 public nftPerAddressLimit = 5;
uint256 public nftLimitPresale = 30;
event CreateElite(uint256 indexed id);
constructor() ERC721("Elite Chess Club", "ECC") {
}
function royaltiesReceiver() public view returns(address) {
}
function setRoyaltiesReceiver(address newRoyaltiesReceiver)
external onlyOwner {
}
function royaltyInfo(uint256 _salePrice) external view
returns (address receiver, uint256 royaltyAmount) {
}
// function set
modifier saleIsOpen() {
}
function _totalSupply() internal view returns (uint256) {
}
function totalMint() public view returns (uint256) {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
uint256 total = _totalSupply();
require(total <= (MAX_ELEMENTS_PRESALE + MAX_ELEMENTS_PUBLIC), "Sale end");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != _ownerOfContract) {
if (isPresale) {
require(<FILL_ME>)
require(msg.value >= priceOfPresale(_count), "Value below price");
if ( isWhitelisted(msg.sender)){
require(ownerMintedCount + _count <= nftLimitPresale, "max NFT per address exceeded for whitelist");
}
else{
require(ownerMintedCount + _count <= nftPerAddressLimit, "Max NFT per address exceeded for Presale");
}
}
else{
require(total + _count <= MAX_ELEMENTS_PUBLIC, "Max limit for public");
require(msg.value >= priceOfPublic(_count), "Value below price");
}
}
for (uint256 i = 1; i <= _count; i++) {
addressMintedBalance[msg.sender]++;
_mintAnElement(_to);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function _mintAnElement(address _to) private {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function addWhitelist(address _user) public onlyOwner {
}
function priceOfPresale(uint256 _count) public view returns (uint256) {
}
function priceOfPublic(uint256 _count) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setPresale(bool _presale) public onlyOwner{
}
}
| total+_count<=MAX_ELEMENTS_PRESALE,"Max limit for presale" | 398,321 | total+_count<=MAX_ELEMENTS_PRESALE |
"max NFT per address exceeded for whitelist" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract EliteChessClub is
ERC721Enumerable,
Ownable,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
address public _royaltiesReceiver = 0x03415648E2e38311640a6C49A8843A69504CFE30;
uint public royaltiesPercentage = 10;
uint256 public constant MAX_ELEMENTS_PRESALE = 1000;
uint256 public constant MAX_ELEMENTS_PUBLIC = 10000;
uint256 public presale_price = 5 * 10**16;
uint256 public public_price = 8 * 10**16;
address private _ownerOfContract;
bool public isPresale = true;
address[] public whitelistedAddresses;
string public baseTokenURI;
mapping(address => uint256) public addressMintedBalance;
uint256 public nftPerAddressLimit = 5;
uint256 public nftLimitPresale = 30;
event CreateElite(uint256 indexed id);
constructor() ERC721("Elite Chess Club", "ECC") {
}
function royaltiesReceiver() public view returns(address) {
}
function setRoyaltiesReceiver(address newRoyaltiesReceiver)
external onlyOwner {
}
function royaltyInfo(uint256 _salePrice) external view
returns (address receiver, uint256 royaltyAmount) {
}
// function set
modifier saleIsOpen() {
}
function _totalSupply() internal view returns (uint256) {
}
function totalMint() public view returns (uint256) {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
uint256 total = _totalSupply();
require(total <= (MAX_ELEMENTS_PRESALE + MAX_ELEMENTS_PUBLIC), "Sale end");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != _ownerOfContract) {
if (isPresale) {
require(total + _count <= MAX_ELEMENTS_PRESALE, "Max limit for presale");
require(msg.value >= priceOfPresale(_count), "Value below price");
if ( isWhitelisted(msg.sender)){
require(<FILL_ME>)
}
else{
require(ownerMintedCount + _count <= nftPerAddressLimit, "Max NFT per address exceeded for Presale");
}
}
else{
require(total + _count <= MAX_ELEMENTS_PUBLIC, "Max limit for public");
require(msg.value >= priceOfPublic(_count), "Value below price");
}
}
for (uint256 i = 1; i <= _count; i++) {
addressMintedBalance[msg.sender]++;
_mintAnElement(_to);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function _mintAnElement(address _to) private {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function addWhitelist(address _user) public onlyOwner {
}
function priceOfPresale(uint256 _count) public view returns (uint256) {
}
function priceOfPublic(uint256 _count) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setPresale(bool _presale) public onlyOwner{
}
}
| ownerMintedCount+_count<=nftLimitPresale,"max NFT per address exceeded for whitelist" | 398,321 | ownerMintedCount+_count<=nftLimitPresale |
"Max NFT per address exceeded for Presale" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract EliteChessClub is
ERC721Enumerable,
Ownable,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
address public _royaltiesReceiver = 0x03415648E2e38311640a6C49A8843A69504CFE30;
uint public royaltiesPercentage = 10;
uint256 public constant MAX_ELEMENTS_PRESALE = 1000;
uint256 public constant MAX_ELEMENTS_PUBLIC = 10000;
uint256 public presale_price = 5 * 10**16;
uint256 public public_price = 8 * 10**16;
address private _ownerOfContract;
bool public isPresale = true;
address[] public whitelistedAddresses;
string public baseTokenURI;
mapping(address => uint256) public addressMintedBalance;
uint256 public nftPerAddressLimit = 5;
uint256 public nftLimitPresale = 30;
event CreateElite(uint256 indexed id);
constructor() ERC721("Elite Chess Club", "ECC") {
}
function royaltiesReceiver() public view returns(address) {
}
function setRoyaltiesReceiver(address newRoyaltiesReceiver)
external onlyOwner {
}
function royaltyInfo(uint256 _salePrice) external view
returns (address receiver, uint256 royaltyAmount) {
}
// function set
modifier saleIsOpen() {
}
function _totalSupply() internal view returns (uint256) {
}
function totalMint() public view returns (uint256) {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
uint256 total = _totalSupply();
require(total <= (MAX_ELEMENTS_PRESALE + MAX_ELEMENTS_PUBLIC), "Sale end");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != _ownerOfContract) {
if (isPresale) {
require(total + _count <= MAX_ELEMENTS_PRESALE, "Max limit for presale");
require(msg.value >= priceOfPresale(_count), "Value below price");
if ( isWhitelisted(msg.sender)){
require(ownerMintedCount + _count <= nftLimitPresale, "max NFT per address exceeded for whitelist");
}
else{
require(<FILL_ME>)
}
}
else{
require(total + _count <= MAX_ELEMENTS_PUBLIC, "Max limit for public");
require(msg.value >= priceOfPublic(_count), "Value below price");
}
}
for (uint256 i = 1; i <= _count; i++) {
addressMintedBalance[msg.sender]++;
_mintAnElement(_to);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function _mintAnElement(address _to) private {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function addWhitelist(address _user) public onlyOwner {
}
function priceOfPresale(uint256 _count) public view returns (uint256) {
}
function priceOfPublic(uint256 _count) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setPresale(bool _presale) public onlyOwner{
}
}
| ownerMintedCount+_count<=nftPerAddressLimit,"Max NFT per address exceeded for Presale" | 398,321 | ownerMintedCount+_count<=nftPerAddressLimit |
"Max limit for public" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract EliteChessClub is
ERC721Enumerable,
Ownable,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
address public _royaltiesReceiver = 0x03415648E2e38311640a6C49A8843A69504CFE30;
uint public royaltiesPercentage = 10;
uint256 public constant MAX_ELEMENTS_PRESALE = 1000;
uint256 public constant MAX_ELEMENTS_PUBLIC = 10000;
uint256 public presale_price = 5 * 10**16;
uint256 public public_price = 8 * 10**16;
address private _ownerOfContract;
bool public isPresale = true;
address[] public whitelistedAddresses;
string public baseTokenURI;
mapping(address => uint256) public addressMintedBalance;
uint256 public nftPerAddressLimit = 5;
uint256 public nftLimitPresale = 30;
event CreateElite(uint256 indexed id);
constructor() ERC721("Elite Chess Club", "ECC") {
}
function royaltiesReceiver() public view returns(address) {
}
function setRoyaltiesReceiver(address newRoyaltiesReceiver)
external onlyOwner {
}
function royaltyInfo(uint256 _salePrice) external view
returns (address receiver, uint256 royaltyAmount) {
}
// function set
modifier saleIsOpen() {
}
function _totalSupply() internal view returns (uint256) {
}
function totalMint() public view returns (uint256) {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
uint256 total = _totalSupply();
require(total <= (MAX_ELEMENTS_PRESALE + MAX_ELEMENTS_PUBLIC), "Sale end");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != _ownerOfContract) {
if (isPresale) {
require(total + _count <= MAX_ELEMENTS_PRESALE, "Max limit for presale");
require(msg.value >= priceOfPresale(_count), "Value below price");
if ( isWhitelisted(msg.sender)){
require(ownerMintedCount + _count <= nftLimitPresale, "max NFT per address exceeded for whitelist");
}
else{
require(ownerMintedCount + _count <= nftPerAddressLimit, "Max NFT per address exceeded for Presale");
}
}
else{
require(<FILL_ME>)
require(msg.value >= priceOfPublic(_count), "Value below price");
}
}
for (uint256 i = 1; i <= _count; i++) {
addressMintedBalance[msg.sender]++;
_mintAnElement(_to);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function _mintAnElement(address _to) private {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function addWhitelist(address _user) public onlyOwner {
}
function priceOfPresale(uint256 _count) public view returns (uint256) {
}
function priceOfPublic(uint256 _count) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setPresale(bool _presale) public onlyOwner{
}
}
| total+_count<=MAX_ELEMENTS_PUBLIC,"Max limit for public" | 398,321 | total+_count<=MAX_ELEMENTS_PUBLIC |
"Address can not be zero address." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./ERC721Pausable.sol";
contract EliteChessClub is
ERC721Enumerable,
Ownable,
ERC721Burnable,
ERC721Pausable
{
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
address public _royaltiesReceiver = 0x03415648E2e38311640a6C49A8843A69504CFE30;
uint public royaltiesPercentage = 10;
uint256 public constant MAX_ELEMENTS_PRESALE = 1000;
uint256 public constant MAX_ELEMENTS_PUBLIC = 10000;
uint256 public presale_price = 5 * 10**16;
uint256 public public_price = 8 * 10**16;
address private _ownerOfContract;
bool public isPresale = true;
address[] public whitelistedAddresses;
string public baseTokenURI;
mapping(address => uint256) public addressMintedBalance;
uint256 public nftPerAddressLimit = 5;
uint256 public nftLimitPresale = 30;
event CreateElite(uint256 indexed id);
constructor() ERC721("Elite Chess Club", "ECC") {
}
function royaltiesReceiver() public view returns(address) {
}
function setRoyaltiesReceiver(address newRoyaltiesReceiver)
external onlyOwner {
}
function royaltyInfo(uint256 _salePrice) external view
returns (address receiver, uint256 royaltyAmount) {
}
// function set
modifier saleIsOpen() {
}
function _totalSupply() internal view returns (uint256) {
}
function totalMint() public view returns (uint256) {
}
function mint(address _to, uint256 _count) public payable saleIsOpen {
}
function isWhitelisted(address _user) public view returns (bool) {
}
function _mintAnElement(address _to) private {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function addWhitelist(address _user) public onlyOwner {
require(<FILL_ME>)
whitelistedAddresses.push( _user );
}
function priceOfPresale(uint256 _count) public view returns (uint256) {
}
function priceOfPublic(uint256 _count) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function walletOfOwner(address _owner)
external
view
returns (uint256[] memory)
{
}
function pause(bool val) public onlyOwner {
}
function withdrawAll() public payable onlyOwner {
}
function _widthdraw(address _address, uint256 _amount) private {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function setPresale(bool _presale) public onlyOwner{
}
}
| address(_user)!=address(0),"Address can not be zero address." | 398,321 | address(_user)!=address(0) |
null | pragma solidity ^0.4.18;
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* Math operations with safety checks
*/
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeDiv(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
contract StandardToken is ERC20, SafeMath {
/* Actual balances of token holders */
mapping(address => uint) balances;
/* approve() allowances */
mapping (address => mapping (address => uint)) allowed;
/* Interface declaration */
function isToken() public constant returns (bool weAre) {
}
function transfer(address _to, uint _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
}
function balanceOf(address _owner) constant returns (uint balance) {
}
function approve(address _spender, uint _value) private returns (bool success) {
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
}
}
contract SmartNodeToken is StandardToken {
string public name = "Smart Node";
string public symbol = "Node";
uint public decimals = 0;
/**
* Boolean contract states
*/
bool halted = false; //the founder address can set this to true to halt the whole ICO event due to emergency
bool preTge = true; //ICO Sale state
bool public freeze = true; //Freeze state
/**
* Initial founder address (set in constructor)
* All deposited ETH will be forwarded to this address.
*/
address founder = 0x0;
address owner = 0x0;
/**
* Token count
*/
uint totalTokens = 40000000; // Unsold tokens will be burned when ICO ends
uint team = 0; // Disabled
uint bounty = 0; // Disabled
/**
*Ico-Sale cap
*/
uint preTgeCap = 40000120; // Max amount raised during Ico-Sale is 36.000 // 1 ETH = 1000 Node tokens
uint tgeCap = 40000120; // Disabled
/**
* Statistic values
*/
uint presaleTokenSupply = 0; // Unused
uint presaleEtherRaised = 0; // Unused
uint preTgeTokenSupply = 0; // This will keep track of the token supply created during the Ico-Sale
event Buy(address indexed sender, uint eth, uint fbt);
/* This generates a public event on the blockchain that will notify clients */
event TokensSent(address indexed to, uint256 value);
event ContributionReceived(address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function SmartNodeToken(address _founder) payable {
}
/**
* 1 ERC20 = 1 FINNEY
* Price is 1000 Node for 1 ETH
*/
function price() constant returns (uint){
}
/**
* The basic entry point to participate the TGE event process.
*
* Pay for funding, get invested tokens back in the sender address.
*/
function buy() public payable returns(bool) {
// Buy allowed if contract is not on halt
require(!halted);
// Amount of wei should be more that 0
require(msg.value>0);
// Count expected tokens price
uint tokens = msg.value / price();
// Total tokens should be more than user want's to buy
require(<FILL_ME>)
if (preTge) {
tokens = tokens;
}
// Check how much tokens already sold
if (preTge) {
// Check that required tokens count are less than tokens already sold on Pre-TGE
require(safeAdd(presaleTokenSupply, tokens) < preTgeCap);
} else {
// Check that required tokens count are less than tokens already sold on tge sub Pre-TGE
require(safeAdd(presaleTokenSupply, tokens) < safeSub(tgeCap, preTgeTokenSupply));
}
// Send wei to founder address
founder.transfer(msg.value);
// Add tokens to user balance and remove from totalSupply
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
// Remove sold tokens from total supply count
balances[owner] = safeSub(balances[owner], tokens);
// Update stats
if (preTge) {
preTgeTokenSupply = safeAdd(preTgeTokenSupply, tokens);
}
presaleTokenSupply = safeAdd(presaleTokenSupply, tokens);
presaleEtherRaised = safeAdd(presaleEtherRaised, msg.value);
// Send buy TBCH token action
Buy(msg.sender, msg.value, tokens);
// /* Emit log events */
TokensSent(msg.sender, tokens);
ContributionReceived(msg.sender, msg.value);
Transfer(owner, msg.sender, tokens);
return true;
}
/**
* Transfer bounty to target address from bounty pool
*/
function sendSupplyTokens(address _to, uint256 _value) onlyOwner() {
}
/**
* ERC 20 Standard Token interface transfer function
*
* Prevent transfers until halt period is over.
*/
function transfer(address _to, uint256 _value) isAvailable() returns (bool success) {
}
/**
* ERC 20 Standard Token interface transfer function
*
* Prevent transfers until halt period is over.
*/
function transferFrom(address _from, address _to, uint256 _value) isAvailable() returns (bool success) {
}
/**
* Burn all tokens from a balance.
*/
function burnRemainingTokens() isAvailable() onlyOwner() {
}
modifier onlyOwner() {
}
modifier isAvailable() {
}
/**
*/
function() payable {
}
/**
* Freeze and unfreeze
*/
function freeze() onlyOwner() {
}
function unFreeze() onlyOwner() {
}
/**
* Replaces an owner
*/
function changeOwner(address _to) onlyOwner() {
}
/**
* Replaces a founder, transfer team pool to new founder balance
*/
function changeFounder(address _to) onlyOwner() {
}
}
| balances[owner]>tokens | 398,332 | balances[owner]>tokens |
null | pragma solidity ^0.4.18;
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* Math operations with safety checks
*/
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeDiv(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
contract StandardToken is ERC20, SafeMath {
/* Actual balances of token holders */
mapping(address => uint) balances;
/* approve() allowances */
mapping (address => mapping (address => uint)) allowed;
/* Interface declaration */
function isToken() public constant returns (bool weAre) {
}
function transfer(address _to, uint _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
}
function balanceOf(address _owner) constant returns (uint balance) {
}
function approve(address _spender, uint _value) private returns (bool success) {
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
}
}
contract SmartNodeToken is StandardToken {
string public name = "Smart Node";
string public symbol = "Node";
uint public decimals = 0;
/**
* Boolean contract states
*/
bool halted = false; //the founder address can set this to true to halt the whole ICO event due to emergency
bool preTge = true; //ICO Sale state
bool public freeze = true; //Freeze state
/**
* Initial founder address (set in constructor)
* All deposited ETH will be forwarded to this address.
*/
address founder = 0x0;
address owner = 0x0;
/**
* Token count
*/
uint totalTokens = 40000000; // Unsold tokens will be burned when ICO ends
uint team = 0; // Disabled
uint bounty = 0; // Disabled
/**
*Ico-Sale cap
*/
uint preTgeCap = 40000120; // Max amount raised during Ico-Sale is 36.000 // 1 ETH = 1000 Node tokens
uint tgeCap = 40000120; // Disabled
/**
* Statistic values
*/
uint presaleTokenSupply = 0; // Unused
uint presaleEtherRaised = 0; // Unused
uint preTgeTokenSupply = 0; // This will keep track of the token supply created during the Ico-Sale
event Buy(address indexed sender, uint eth, uint fbt);
/* This generates a public event on the blockchain that will notify clients */
event TokensSent(address indexed to, uint256 value);
event ContributionReceived(address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function SmartNodeToken(address _founder) payable {
}
/**
* 1 ERC20 = 1 FINNEY
* Price is 1000 Node for 1 ETH
*/
function price() constant returns (uint){
}
/**
* The basic entry point to participate the TGE event process.
*
* Pay for funding, get invested tokens back in the sender address.
*/
function buy() public payable returns(bool) {
// Buy allowed if contract is not on halt
require(!halted);
// Amount of wei should be more that 0
require(msg.value>0);
// Count expected tokens price
uint tokens = msg.value / price();
// Total tokens should be more than user want's to buy
require(balances[owner]>tokens);
if (preTge) {
tokens = tokens;
}
// Check how much tokens already sold
if (preTge) {
// Check that required tokens count are less than tokens already sold on Pre-TGE
require(<FILL_ME>)
} else {
// Check that required tokens count are less than tokens already sold on tge sub Pre-TGE
require(safeAdd(presaleTokenSupply, tokens) < safeSub(tgeCap, preTgeTokenSupply));
}
// Send wei to founder address
founder.transfer(msg.value);
// Add tokens to user balance and remove from totalSupply
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
// Remove sold tokens from total supply count
balances[owner] = safeSub(balances[owner], tokens);
// Update stats
if (preTge) {
preTgeTokenSupply = safeAdd(preTgeTokenSupply, tokens);
}
presaleTokenSupply = safeAdd(presaleTokenSupply, tokens);
presaleEtherRaised = safeAdd(presaleEtherRaised, msg.value);
// Send buy TBCH token action
Buy(msg.sender, msg.value, tokens);
// /* Emit log events */
TokensSent(msg.sender, tokens);
ContributionReceived(msg.sender, msg.value);
Transfer(owner, msg.sender, tokens);
return true;
}
/**
* Transfer bounty to target address from bounty pool
*/
function sendSupplyTokens(address _to, uint256 _value) onlyOwner() {
}
/**
* ERC 20 Standard Token interface transfer function
*
* Prevent transfers until halt period is over.
*/
function transfer(address _to, uint256 _value) isAvailable() returns (bool success) {
}
/**
* ERC 20 Standard Token interface transfer function
*
* Prevent transfers until halt period is over.
*/
function transferFrom(address _from, address _to, uint256 _value) isAvailable() returns (bool success) {
}
/**
* Burn all tokens from a balance.
*/
function burnRemainingTokens() isAvailable() onlyOwner() {
}
modifier onlyOwner() {
}
modifier isAvailable() {
}
/**
*/
function() payable {
}
/**
* Freeze and unfreeze
*/
function freeze() onlyOwner() {
}
function unFreeze() onlyOwner() {
}
/**
* Replaces an owner
*/
function changeOwner(address _to) onlyOwner() {
}
/**
* Replaces a founder, transfer team pool to new founder balance
*/
function changeFounder(address _to) onlyOwner() {
}
}
| safeAdd(presaleTokenSupply,tokens)<preTgeCap | 398,332 | safeAdd(presaleTokenSupply,tokens)<preTgeCap |
null | pragma solidity ^0.4.18;
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* Math operations with safety checks
*/
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeDiv(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
contract StandardToken is ERC20, SafeMath {
/* Actual balances of token holders */
mapping(address => uint) balances;
/* approve() allowances */
mapping (address => mapping (address => uint)) allowed;
/* Interface declaration */
function isToken() public constant returns (bool weAre) {
}
function transfer(address _to, uint _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
}
function balanceOf(address _owner) constant returns (uint balance) {
}
function approve(address _spender, uint _value) private returns (bool success) {
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
}
}
contract SmartNodeToken is StandardToken {
string public name = "Smart Node";
string public symbol = "Node";
uint public decimals = 0;
/**
* Boolean contract states
*/
bool halted = false; //the founder address can set this to true to halt the whole ICO event due to emergency
bool preTge = true; //ICO Sale state
bool public freeze = true; //Freeze state
/**
* Initial founder address (set in constructor)
* All deposited ETH will be forwarded to this address.
*/
address founder = 0x0;
address owner = 0x0;
/**
* Token count
*/
uint totalTokens = 40000000; // Unsold tokens will be burned when ICO ends
uint team = 0; // Disabled
uint bounty = 0; // Disabled
/**
*Ico-Sale cap
*/
uint preTgeCap = 40000120; // Max amount raised during Ico-Sale is 36.000 // 1 ETH = 1000 Node tokens
uint tgeCap = 40000120; // Disabled
/**
* Statistic values
*/
uint presaleTokenSupply = 0; // Unused
uint presaleEtherRaised = 0; // Unused
uint preTgeTokenSupply = 0; // This will keep track of the token supply created during the Ico-Sale
event Buy(address indexed sender, uint eth, uint fbt);
/* This generates a public event on the blockchain that will notify clients */
event TokensSent(address indexed to, uint256 value);
event ContributionReceived(address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function SmartNodeToken(address _founder) payable {
}
/**
* 1 ERC20 = 1 FINNEY
* Price is 1000 Node for 1 ETH
*/
function price() constant returns (uint){
}
/**
* The basic entry point to participate the TGE event process.
*
* Pay for funding, get invested tokens back in the sender address.
*/
function buy() public payable returns(bool) {
// Buy allowed if contract is not on halt
require(!halted);
// Amount of wei should be more that 0
require(msg.value>0);
// Count expected tokens price
uint tokens = msg.value / price();
// Total tokens should be more than user want's to buy
require(balances[owner]>tokens);
if (preTge) {
tokens = tokens;
}
// Check how much tokens already sold
if (preTge) {
// Check that required tokens count are less than tokens already sold on Pre-TGE
require(safeAdd(presaleTokenSupply, tokens) < preTgeCap);
} else {
// Check that required tokens count are less than tokens already sold on tge sub Pre-TGE
require(<FILL_ME>)
}
// Send wei to founder address
founder.transfer(msg.value);
// Add tokens to user balance and remove from totalSupply
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
// Remove sold tokens from total supply count
balances[owner] = safeSub(balances[owner], tokens);
// Update stats
if (preTge) {
preTgeTokenSupply = safeAdd(preTgeTokenSupply, tokens);
}
presaleTokenSupply = safeAdd(presaleTokenSupply, tokens);
presaleEtherRaised = safeAdd(presaleEtherRaised, msg.value);
// Send buy TBCH token action
Buy(msg.sender, msg.value, tokens);
// /* Emit log events */
TokensSent(msg.sender, tokens);
ContributionReceived(msg.sender, msg.value);
Transfer(owner, msg.sender, tokens);
return true;
}
/**
* Transfer bounty to target address from bounty pool
*/
function sendSupplyTokens(address _to, uint256 _value) onlyOwner() {
}
/**
* ERC 20 Standard Token interface transfer function
*
* Prevent transfers until halt period is over.
*/
function transfer(address _to, uint256 _value) isAvailable() returns (bool success) {
}
/**
* ERC 20 Standard Token interface transfer function
*
* Prevent transfers until halt period is over.
*/
function transferFrom(address _from, address _to, uint256 _value) isAvailable() returns (bool success) {
}
/**
* Burn all tokens from a balance.
*/
function burnRemainingTokens() isAvailable() onlyOwner() {
}
modifier onlyOwner() {
}
modifier isAvailable() {
}
/**
*/
function() payable {
}
/**
* Freeze and unfreeze
*/
function freeze() onlyOwner() {
}
function unFreeze() onlyOwner() {
}
/**
* Replaces an owner
*/
function changeOwner(address _to) onlyOwner() {
}
/**
* Replaces a founder, transfer team pool to new founder balance
*/
function changeFounder(address _to) onlyOwner() {
}
}
| safeAdd(presaleTokenSupply,tokens)<safeSub(tgeCap,preTgeTokenSupply) | 398,332 | safeAdd(presaleTokenSupply,tokens)<safeSub(tgeCap,preTgeTokenSupply) |
null | pragma solidity ^0.4.18;
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
event Transfer(address indexed from, address indexed to, uint value);
}
/**
* Math operations with safety checks
*/
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
}
function safeDiv(uint a, uint b) internal returns (uint) {
}
function safeSub(uint a, uint b) internal returns (uint) {
}
function safeAdd(uint a, uint b) internal returns (uint) {
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
contract StandardToken is ERC20, SafeMath {
/* Actual balances of token holders */
mapping(address => uint) balances;
/* approve() allowances */
mapping (address => mapping (address => uint)) allowed;
/* Interface declaration */
function isToken() public constant returns (bool weAre) {
}
function transfer(address _to, uint _value) returns (bool success) {
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
}
function balanceOf(address _owner) constant returns (uint balance) {
}
function approve(address _spender, uint _value) private returns (bool success) {
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
}
}
contract SmartNodeToken is StandardToken {
string public name = "Smart Node";
string public symbol = "Node";
uint public decimals = 0;
/**
* Boolean contract states
*/
bool halted = false; //the founder address can set this to true to halt the whole ICO event due to emergency
bool preTge = true; //ICO Sale state
bool public freeze = true; //Freeze state
/**
* Initial founder address (set in constructor)
* All deposited ETH will be forwarded to this address.
*/
address founder = 0x0;
address owner = 0x0;
/**
* Token count
*/
uint totalTokens = 40000000; // Unsold tokens will be burned when ICO ends
uint team = 0; // Disabled
uint bounty = 0; // Disabled
/**
*Ico-Sale cap
*/
uint preTgeCap = 40000120; // Max amount raised during Ico-Sale is 36.000 // 1 ETH = 1000 Node tokens
uint tgeCap = 40000120; // Disabled
/**
* Statistic values
*/
uint presaleTokenSupply = 0; // Unused
uint presaleEtherRaised = 0; // Unused
uint preTgeTokenSupply = 0; // This will keep track of the token supply created during the Ico-Sale
event Buy(address indexed sender, uint eth, uint fbt);
/* This generates a public event on the blockchain that will notify clients */
event TokensSent(address indexed to, uint256 value);
event ContributionReceived(address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function SmartNodeToken(address _founder) payable {
}
/**
* 1 ERC20 = 1 FINNEY
* Price is 1000 Node for 1 ETH
*/
function price() constant returns (uint){
}
/**
* The basic entry point to participate the TGE event process.
*
* Pay for funding, get invested tokens back in the sender address.
*/
function buy() public payable returns(bool) {
}
/**
* Transfer bounty to target address from bounty pool
*/
function sendSupplyTokens(address _to, uint256 _value) onlyOwner() {
}
/**
* ERC 20 Standard Token interface transfer function
*
* Prevent transfers until halt period is over.
*/
function transfer(address _to, uint256 _value) isAvailable() returns (bool success) {
}
/**
* ERC 20 Standard Token interface transfer function
*
* Prevent transfers until halt period is over.
*/
function transferFrom(address _from, address _to, uint256 _value) isAvailable() returns (bool success) {
}
/**
* Burn all tokens from a balance.
*/
function burnRemainingTokens() isAvailable() onlyOwner() {
}
modifier onlyOwner() {
}
modifier isAvailable() {
require(<FILL_ME>)
_;
}
/**
*/
function() payable {
}
/**
* Freeze and unfreeze
*/
function freeze() onlyOwner() {
}
function unFreeze() onlyOwner() {
}
/**
* Replaces an owner
*/
function changeOwner(address _to) onlyOwner() {
}
/**
* Replaces a founder, transfer team pool to new founder balance
*/
function changeFounder(address _to) onlyOwner() {
}
}
| !halted&&!freeze | 398,332 | !halted&&!freeze |
"The entry already exists" | // These days even gemtokens becomes rugtokens, which we are against. Introducing AntiscamToken, a fork of insidual which is a fork of SHUF. Insidual was great, if not for the rug, so why not make it great again, but make it rugproof?
// We are in no way associated with SHUF nor Insidual*
pragma solidity ^0.5.17;
contract Ownable {
address public owner;
event TransferOwnership(address _from, address _to);
constructor() public {
}
modifier onlyOwner() {
}
function setOwner(address _owner) external onlyOwner {
}
}
pragma solidity ^0.5.17;
contract StorageUnit {
address private owner;
mapping(bytes32 => bytes32) private store;
constructor() public {
}
function write(bytes32 _key, bytes32 _value) external {
}
function read(bytes32 _key) external view returns (bytes32) {
}
}
pragma solidity ^0.5.17;
library IsContract {
function isContract(address _addr) internal view returns (bool) {
}
}
pragma solidity ^0.5.17;
library DistributedStorage {
function contractSlot(bytes32 _struct) private view returns (address) {
}
function deploy(bytes32 _struct) private {
}
function write(
bytes32 _struct,
bytes32 _key,
bytes32 _value
) internal {
}
function read(
bytes32 _struct,
bytes32 _key
) internal view returns (bytes32) {
}
}
pragma solidity ^0.5.17;
contract Inject {
bytes32 private stub;
modifier requestGas(uint256 _factor) {
}
}
pragma solidity ^0.5.17;
interface IERC20 {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
function approve(address _spender, uint256 _value) external returns (bool success);
function balanceOf(address _owner) external view returns (uint256 balance);
}
pragma solidity ^0.5.17;
library AddressMinMound {
using AddressMinMound for AddressMinMound.Mound;
struct Mound {
uint256[] entries;
mapping(address => uint256) index;
}
function initialize(Mound storage _mound) internal {
}
function encode(address _addr, uint256 _value) internal pure returns (uint256 _entry) {
}
function decode(uint256 _entry) internal pure returns (address _addr, uint256 _value) {
}
function decodeAddress(uint256 _entry) internal pure returns (address _addr) {
}
function top(Mound storage _mound) internal view returns(address, uint256) {
}
function has(Mound storage _mound, address _addr) internal view returns (bool) {
}
function size(Mound storage _mound) internal view returns (uint256) {
}
function entry(Mound storage _mound, uint256 _i) internal view returns (address, uint256) {
}
function popTop(Mound storage _mound) internal returns(address _addr, uint256 _value) {
}
function insert(Mound storage _mound, address _addr, uint256 _value) internal {
require(<FILL_ME>)
uint256 encoded = encode(_addr, _value);
_mound.entries.push(encoded);
uint256 currentIndex = _mound.entries.length - 1;
currentIndex = _mound.inflatIt(currentIndex, encoded);
_mound.index[_addr] = currentIndex;
}
function update(Mound storage _mound, address _addr, uint256 _value) internal {
}
function inflatIt(Mound storage _mound, uint256 _ind, uint256 _val) internal returns (uint256 ind) {
}
function deflatIt(Mound storage _mound, uint256 _ind, uint256 _val) internal returns (uint256 ind) {
}
}
pragma solidity ^0.5.17;
contract Mound is Ownable {
using AddressMinMound for AddressMinMound.Mound;
// Mound
AddressMinMound.Mound private mound;
// Mound events
event Joinmound(address indexed _address, uint256 _balance, uint256 _prevSize);
event Leavemound(address indexed _address, uint256 _balance, uint256 _prevSize);
uint256 public constant TOP_SIZE = 100;
constructor() public {
}
function topSize() external pure returns (uint256) {
}
function addressAt(uint256 _i) external view returns (address addr) {
}
function indexOf(address _addr) external view returns (uint256) {
}
function entry(uint256 _i) external view returns (address, uint256) {
}
function top() external view returns (address, uint256) {
}
function size() external view returns (uint256) {
}
function update(address _addr, uint256 _new) external onlyOwner {
}
}
pragma solidity ^0.5.17;
contract AntiscamToken is Ownable, Inject, IERC20 {
using DistributedStorage for bytes32;
using SafeMath for uint256;
// Distribution
event Choosen(address indexed _addr, uint256 _value);
// Org
event SetName(string _prev, string _new);
event SetExtraGas(uint256 _prev, uint256 _new);
event Setmound(address _prev, address _new);
event WhitelistFrom(address _addr, bool _whitelisted);
event WhitelistTo(address _addr, bool _whitelisted);
uint256 public totalSupply;
bytes32 private constant BALANCE_KEY = keccak256("balance");
// Mechanism
uint256 public constant FEE = 50;
// Token
string public name = "AntiscamToken (AST)";
string public constant symbol = "AST";
uint8 public constant decimals = 18;
// fee whitelist
mapping(address => bool) public whitelistFrom;
mapping(address => bool) public whitelistTo;
// mound
Mound public mound;
// internal
uint256 public extraGas;
bool inited;
function init(
address _to,
uint256 _amount
) external {
}
// Get Functions
function _toKey(address a) internal pure returns (bytes32) {
}
function _balanceOf(address _addr) internal view returns (uint256) {
}
function _allowance(address _addr, address _spender) internal view returns (uint256) {
}
function _nonce(address _addr, uint256 _cat) internal view returns (uint256) {
}
// Set Functions
function _setAllowance(address _addr, address _spender, uint256 _value) internal {
}
function _setNonce(address _addr, uint256 _cat, uint256 _value) internal {
}
function _setBalance(address _addr, uint256 _balance) internal {
}
// Distribution Functions
function _isWhitelisted(address _from, address _to) internal view returns (bool) {
}
function _random(address _s1, uint256 _s2, uint256 _s3, uint256 _max) internal pure returns (uint256) {
}
function _pickChoosen(address _from, uint256 _value) internal returns (address choosen) {
}
function _transferFrom(address _operator, address _from, address _to, uint256 _value, bool _payFee) internal {
}
// Org functions
function setWhitelistedTo(address _addr, bool _whitelisted) external onlyOwner {
}
function setWhitelistedFrom(address _addr, bool _whitelisted) external onlyOwner {
}
function setName(string calldata _name) external onlyOwner {
}
function setExtraGas(uint256 _gas) external onlyOwner {
}
function setmound(Mound _mound) external onlyOwner {
}
// Mound functions
function topSize() external view returns (uint256) {
}
function moundSize() external view returns (uint256) {
}
function moundEntry(uint256 _i) external view returns (address, uint256) {
}
function moundTop() external view returns (address, uint256) {
}
function moundIndex(address _addr) external view returns (uint256) {
}
function getNonce(address _addr, uint256 _cat) external view returns (uint256) {
}
// ERC20 functions
function balanceOf(address _addr) external view returns (uint256) {
}
function allowance(address _addr, address _spender) external view returns (uint256) {
}
function approve(address _spender, uint256 _value) external returns (bool) {
}
function transfer(address _to, uint256 _value) external requestGas(extraGas) returns (bool) {
}
function transferWithFee(address _to, uint256 _value) external requestGas(extraGas) returns (bool) {
}
function transferFrom(address _from, address _to, uint256 _value) external requestGas(extraGas) returns (bool) {
}
function transferFromWithFee(address _from, address _to, uint256 _value) external requestGas(extraGas) returns (bool) {
}
}
pragma solidity ^0.5.17;
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns (uint256) {
}
function sub(uint256 x, uint256 y) internal pure returns (uint256) {
}
function mult(uint256 x, uint256 y) internal pure returns (uint256) {
}
function div(uint256 x, uint256 y) internal pure returns (uint256) {
}
function divRound(uint256 x, uint256 y) internal pure returns (uint256) {
}
}
pragma solidity ^0.5.17;
library Math {
function orderOfMagnitude(uint256 input) internal pure returns (uint256){
}
function min(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
function max(uint256 _a, uint256 _b) internal pure returns (uint256) {
}
}
| _mound.index[_addr]==0,"The entry already exists" | 398,396 | _mound.index[_addr]==0 |
"Insufficient number of tokens to complete purchase!" | contract ClarityCrowdsale is
Crowdsale,
TimedCrowdsale,
PostDeliveryCrowdsale,
FinalizableCrowdsale,
Whitelist
{
address private advisorWallet; // forward all phase one funds here
uint256 private phaseOneRate; // rate for phase one
uint256 private phaseTwoRate; // rate for phase teo
uint256 private phaseOneTokens = 10000000 * 10**18; // tokens available in phase one
uint256 private phaseTwoTokens = 30000000 * 10**18; // tokens available in phase two
mapping (address => address) referrals; // Keep track of referrals for bonuses
modifier onlyFounders() {
}
constructor(
uint256 _phaseOneRate,
uint256 _phaseTwoRate,
address _advisorWallet,
address _founderWallet,
uint256 _openingTime,
uint256 _closingTime,
IERC20 _token
)
Crowdsale(_phaseTwoRate, _founderWallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
public
{
}
// overridden from Crowdsale parent contract
function _getTokenAmount(uint256 weiAmount)
internal view returns (uint256)
{
}
// overridden from Crowdsale parent contract
function _forwardFunds()
internal
{
}
// overridden from Crowdsale parent contract
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
onlyIfWhitelisted(beneficiary)
{
require(<FILL_ME>)
super._preValidatePurchase(beneficiary, weiAmount);
}
// overridden from Crowdsale parent contract
function _finalization()
internal
onlyFounders
{
}
function tokensLeft()
public
view
returns (uint256)
{
}
function addReferral(address beneficiary, address referrer)
external
onlyAdmins
onlyIfWhitelisted(referrer)
onlyIfWhitelisted(beneficiary)
{
}
// overridden from Crowdsale parent contract
function _processPurchase(
address beneficiary,
uint256 tokenAmount
)
internal
{
}
}
| tokensLeft()>=_getTokenAmount(weiAmount),"Insufficient number of tokens to complete purchase!" | 398,544 | tokensLeft()>=_getTokenAmount(weiAmount) |
"Main Sale is Paused" | pragma solidity ^0.8.11;
/**
* @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.11;
contract RainbowCats is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.0 ether;
uint256 public maxSupply = 5000;
uint256 public maxMintAmount = 5;
uint256 public reserved = 50;
uint256 public nftPerAddressLimit = 1;
bool public isPublicSaleActive = false;
bool public isWhitelistSaleActive = true;
bool public revealed = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
mapping(address => uint256) public addressMintedBalance;
constructor (
string memory _initBaseURI,
string memory _initNotRevealedUri)
ERC721 ("Rainbow Cats", "RCAT") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
require(<FILL_ME>)
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
}
function mintPresale(uint256 _mintAmount) external payable {
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function checkWhiteList(address addr) external view returns (uint256) {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setPublicSaleStatus() external onlyOwner {
}
function setWhiteListSaleStatus() external onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function mintReserved(uint256 _amount) public onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| !isPublicSaleActive,"Main Sale is Paused" | 398,556 | !isPublicSaleActive |
"It has not been 8 hours since you staked yet" | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface Uniswap{
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function WETH() external pure returns (address);
}
interface Pool{
function primary() external view returns (address);
}
contract Poolable{
address payable internal constant _POOLADDRESS = 0xdbd53a92ff1b7577c82d229f68865fF9f17ACc17;
function primary() private view returns (address) {
}
modifier onlyPrimary() {
}
}
contract Staker is Poolable{
using SafeMath for uint256;
uint constant internal DECIMAL = 10**18;
uint constant public INF = 33136721748;
uint private _rewardValue = 10**18;
mapping (address => uint256) public timePooled;
mapping (address => uint256) private internalTime;
mapping (address => uint256) private LPTokenBalance;
mapping (address => uint256) private rewards;
mapping (address => uint256) private referralEarned;
address public orbAddress;
address constant public UNIROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public WETHAddress = Uniswap(UNIROUTER).WETH();
bool private _unchangeable = false;
bool private _tokenAddressGiven = false;
receive() external payable {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
//If true, no changes can be made
function unchangeable() public view returns (bool){
}
function rewardValue() public view returns (uint){
}
//THE ONLY ADMIN FUNCTIONS vvvv
//After this is called, no changes can be made
function makeUnchangeable() public{
}
//Can only be called once to set token address
function setTokenAddress(address input) public{
}
//Set reward value that has high APY, can't be called if makeUnchangeable() was called
function updateRewardValue(uint input) public {
}
//THE ONLY ADMIN FUNCTIONS ^^^^
function stake(address staker, address payable ref) public payable{
}
function withdrawLPTokens(uint amount) public {
require(<FILL_ME>)
rewards[msg.sender] = rewards[msg.sender].add(viewRecentRewardTokenAmount(msg.sender));
LPTokenBalance[msg.sender] = LPTokenBalance[msg.sender].sub(amount);
address poolAddress = Uniswap(FACTORY).getPair(orbAddress, WETHAddress);
IERC20(poolAddress).transfer(msg.sender, amount);
internalTime[msg.sender] = now;
}
function withdrawRewardTokens(uint amount) public {
}
function withdrawReferralEarned(uint amount) public{
}
function viewRecentRewardTokenAmount(address who) internal view returns (uint){
}
function viewRewardTokenAmount(address who) public view returns (uint){
}
function viewLPTokenAmount(address who) public view returns (uint){
}
function viewPooledEthAmount(address who) public view returns (uint){
}
function viewPooledTokenAmount(address who) public view returns (uint){
}
function viewReferralEarned(address who) public view returns (uint){
}
function price() public view returns (uint){
}
function earnCalc(uint ethTime) public view returns(uint){
}
function ethtimeCalc(uint orb) internal view returns(uint){
}
}
| timePooled[msg.sender]+8hours<=now,"It has not been 8 hours since you staked yet" | 398,571 | timePooled[msg.sender]+8hours<=now |
"contract returned an unknown value from onERC1155Received" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
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 CommonConstants {
bytes4 constant internal ERC1155_ACCEPTED = 0xf23a6e61; // bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))
bytes4 constant internal ERC1155_BATCH_ACCEPTED = 0xbc197c81; // bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))
}
interface ERC1155TokenReceiver {
function onERC1155Received(address _operator, address _from, uint256 _id, uint256 _value, bytes calldata _data) external returns(bytes4);
function onERC1155BatchReceived(address _operator, address _from, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external returns(bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value);
event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _value, uint256 indexed _id);
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external;
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view returns (uint256[] memory);
}
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () {
}
function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function toPayable(address account) internal pure returns (address payable) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
// A sample implementation of core ERC1155 function.
contract ERC1155 is IERC1155, ERC165, CommonConstants {
using SafeMath for uint256;
using Address for address;
// id => (owner => balance)
mapping (uint256 => mapping(address => uint256)) internal balances;
// owner => (operator => approved)
mapping (address => mapping(address => bool)) internal operatorApproval;
bytes4 constant private INTERFACE_SIGNATURE_ERC1155 = 0xd9b67a26;
constructor() {
}
/////////////////////////////////////////// ERC1155 //////////////////////////////////////////////
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external override{
}
function balanceOf(address _owner, uint256 _id) external view override returns (uint256) {
}
function setApprovalForAll(address _operator, bool _approved) external override {
}
function isApprovedForAll(address _owner, address _operator) external view override returns (bool) {
}
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external override {
}
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view override returns (uint256[] memory) {
}
function _doSafeTransferAcceptanceCheck(address _operator, address _from, address _to, uint256 _id, uint256 _value, bytes memory _data) internal {
require(<FILL_ME>)
}
function _doSafeBatchTransferAcceptanceCheck(address _operator, address _from, address _to, uint256[] memory _ids, uint256[] memory _values, bytes memory _data) internal {
}
}
library StringLibrary {
function append(string memory _a, string memory _b) internal pure returns (string memory) {
}
function append(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
}
function concat(bytes memory _ba, bytes memory _bb, bytes memory _bc, bytes memory _bd, bytes memory _be, bytes memory _bf, bytes memory _bg) internal pure returns (bytes memory) {
}
}
contract HasContractURI is ERC165 {
string public contractURI;
bytes4 private constant _INTERFACE_ID_CONTRACT_URI = 0xe8a3d485;
constructor(string memory _contractURI) {
}
function _setContractURI(string memory _contractURI) internal {
}
}
contract HasTokenURI {
using StringLibrary for string;
string public tokenURIPrefix;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
constructor(string memory _tokenURIPrefix) {
}
function _tokenURI(uint256 tokenId) internal view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function _setTokenURIPrefix(string memory _tokenURIPrefix) internal {
}
function _clearTokenURI(uint256 tokenId) internal {
}
function uri(uint256 _id) external view returns (string memory) {
}
}
contract Context {
constructor () { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
contract ERC1155Base is Ownable, HasTokenURI, HasContractURI, ERC1155 {
using SafeMath for uint256;
mapping (uint256 => address) public creators;
mapping (uint256 => string) public images;
constructor(string memory contractURI, string memory tokenURIPrefix) HasContractURI(contractURI) HasTokenURI(tokenURIPrefix) {
}
function _mint(uint256 _id, uint256 _supply, string memory _uri, string memory image) internal {
}
function burn(address _owner, uint256 _id, uint256 _value) external {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal override {
}
function setTokenURIPrefix(string memory tokenURIPrefix) public onlyOwner {
}
function setContractURI(string memory contractURI) public onlyOwner {
}
}
contract ShontelleNFT is Ownable, ERC1155Base {
event CreateERC1155_v1(address indexed creator, string name, string symbol);
string public name;
string public symbol;
constructor(string memory _name, string memory _symbol, string memory contractURI, string memory tokenURIPrefix) ERC1155Base(contractURI, tokenURIPrefix) {
}
function mint(uint256 id, uint256 supply, string memory uri, string memory image) onlyOwner public {
}
function batchMint(uint256[] memory _ids, uint256[] memory _quantities, string[] memory uri, string[] memory image) onlyOwner public {
}
}
| ERC1155TokenReceiver(_to).onERC1155Received(_operator,_from,_id,_value,_data)==ERC1155_ACCEPTED,"contract returned an unknown value from onERC1155Received" | 398,635 | ERC1155TokenReceiver(_to).onERC1155Received(_operator,_from,_id,_value,_data)==ERC1155_ACCEPTED |
"contract returned an unknown value from onERC1155BatchReceived" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
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 CommonConstants {
bytes4 constant internal ERC1155_ACCEPTED = 0xf23a6e61; // bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))
bytes4 constant internal ERC1155_BATCH_ACCEPTED = 0xbc197c81; // bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))
}
interface ERC1155TokenReceiver {
function onERC1155Received(address _operator, address _from, uint256 _id, uint256 _value, bytes calldata _data) external returns(bytes4);
function onERC1155BatchReceived(address _operator, address _from, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external returns(bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value);
event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _value, uint256 indexed _id);
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external;
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view returns (uint256[] memory);
}
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () {
}
function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function toPayable(address account) internal pure returns (address payable) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
// A sample implementation of core ERC1155 function.
contract ERC1155 is IERC1155, ERC165, CommonConstants {
using SafeMath for uint256;
using Address for address;
// id => (owner => balance)
mapping (uint256 => mapping(address => uint256)) internal balances;
// owner => (operator => approved)
mapping (address => mapping(address => bool)) internal operatorApproval;
bytes4 constant private INTERFACE_SIGNATURE_ERC1155 = 0xd9b67a26;
constructor() {
}
/////////////////////////////////////////// ERC1155 //////////////////////////////////////////////
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external override{
}
function balanceOf(address _owner, uint256 _id) external view override returns (uint256) {
}
function setApprovalForAll(address _operator, bool _approved) external override {
}
function isApprovedForAll(address _owner, address _operator) external view override returns (bool) {
}
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external override {
}
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view override returns (uint256[] memory) {
}
function _doSafeTransferAcceptanceCheck(address _operator, address _from, address _to, uint256 _id, uint256 _value, bytes memory _data) internal {
}
function _doSafeBatchTransferAcceptanceCheck(address _operator, address _from, address _to, uint256[] memory _ids, uint256[] memory _values, bytes memory _data) internal {
require(<FILL_ME>)
}
}
library StringLibrary {
function append(string memory _a, string memory _b) internal pure returns (string memory) {
}
function append(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
}
function concat(bytes memory _ba, bytes memory _bb, bytes memory _bc, bytes memory _bd, bytes memory _be, bytes memory _bf, bytes memory _bg) internal pure returns (bytes memory) {
}
}
contract HasContractURI is ERC165 {
string public contractURI;
bytes4 private constant _INTERFACE_ID_CONTRACT_URI = 0xe8a3d485;
constructor(string memory _contractURI) {
}
function _setContractURI(string memory _contractURI) internal {
}
}
contract HasTokenURI {
using StringLibrary for string;
string public tokenURIPrefix;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
constructor(string memory _tokenURIPrefix) {
}
function _tokenURI(uint256 tokenId) internal view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function _setTokenURIPrefix(string memory _tokenURIPrefix) internal {
}
function _clearTokenURI(uint256 tokenId) internal {
}
function uri(uint256 _id) external view returns (string memory) {
}
}
contract Context {
constructor () { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
contract ERC1155Base is Ownable, HasTokenURI, HasContractURI, ERC1155 {
using SafeMath for uint256;
mapping (uint256 => address) public creators;
mapping (uint256 => string) public images;
constructor(string memory contractURI, string memory tokenURIPrefix) HasContractURI(contractURI) HasTokenURI(tokenURIPrefix) {
}
function _mint(uint256 _id, uint256 _supply, string memory _uri, string memory image) internal {
}
function burn(address _owner, uint256 _id, uint256 _value) external {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal override {
}
function setTokenURIPrefix(string memory tokenURIPrefix) public onlyOwner {
}
function setContractURI(string memory contractURI) public onlyOwner {
}
}
contract ShontelleNFT is Ownable, ERC1155Base {
event CreateERC1155_v1(address indexed creator, string name, string symbol);
string public name;
string public symbol;
constructor(string memory _name, string memory _symbol, string memory contractURI, string memory tokenURIPrefix) ERC1155Base(contractURI, tokenURIPrefix) {
}
function mint(uint256 id, uint256 supply, string memory uri, string memory image) onlyOwner public {
}
function batchMint(uint256[] memory _ids, uint256[] memory _quantities, string[] memory uri, string[] memory image) onlyOwner public {
}
}
| ERC1155TokenReceiver(_to).onERC1155BatchReceived(_operator,_from,_ids,_values,_data)==ERC1155_BATCH_ACCEPTED,"contract returned an unknown value from onERC1155BatchReceived" | 398,635 | ERC1155TokenReceiver(_to).onERC1155BatchReceived(_operator,_from,_ids,_values,_data)==ERC1155_BATCH_ACCEPTED |
"Token is already minted" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
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 CommonConstants {
bytes4 constant internal ERC1155_ACCEPTED = 0xf23a6e61; // bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))
bytes4 constant internal ERC1155_BATCH_ACCEPTED = 0xbc197c81; // bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))
}
interface ERC1155TokenReceiver {
function onERC1155Received(address _operator, address _from, uint256 _id, uint256 _value, bytes calldata _data) external returns(bytes4);
function onERC1155BatchReceived(address _operator, address _from, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external returns(bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value);
event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _value, uint256 indexed _id);
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external;
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view returns (uint256[] memory);
}
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () {
}
function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function toPayable(address account) internal pure returns (address payable) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
// A sample implementation of core ERC1155 function.
contract ERC1155 is IERC1155, ERC165, CommonConstants {
using SafeMath for uint256;
using Address for address;
// id => (owner => balance)
mapping (uint256 => mapping(address => uint256)) internal balances;
// owner => (operator => approved)
mapping (address => mapping(address => bool)) internal operatorApproval;
bytes4 constant private INTERFACE_SIGNATURE_ERC1155 = 0xd9b67a26;
constructor() {
}
/////////////////////////////////////////// ERC1155 //////////////////////////////////////////////
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external override{
}
function balanceOf(address _owner, uint256 _id) external view override returns (uint256) {
}
function setApprovalForAll(address _operator, bool _approved) external override {
}
function isApprovedForAll(address _owner, address _operator) external view override returns (bool) {
}
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external override {
}
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view override returns (uint256[] memory) {
}
function _doSafeTransferAcceptanceCheck(address _operator, address _from, address _to, uint256 _id, uint256 _value, bytes memory _data) internal {
}
function _doSafeBatchTransferAcceptanceCheck(address _operator, address _from, address _to, uint256[] memory _ids, uint256[] memory _values, bytes memory _data) internal {
}
}
library StringLibrary {
function append(string memory _a, string memory _b) internal pure returns (string memory) {
}
function append(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
}
function concat(bytes memory _ba, bytes memory _bb, bytes memory _bc, bytes memory _bd, bytes memory _be, bytes memory _bf, bytes memory _bg) internal pure returns (bytes memory) {
}
}
contract HasContractURI is ERC165 {
string public contractURI;
bytes4 private constant _INTERFACE_ID_CONTRACT_URI = 0xe8a3d485;
constructor(string memory _contractURI) {
}
function _setContractURI(string memory _contractURI) internal {
}
}
contract HasTokenURI {
using StringLibrary for string;
string public tokenURIPrefix;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
constructor(string memory _tokenURIPrefix) {
}
function _tokenURI(uint256 tokenId) internal view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function _setTokenURIPrefix(string memory _tokenURIPrefix) internal {
}
function _clearTokenURI(uint256 tokenId) internal {
}
function uri(uint256 _id) external view returns (string memory) {
}
}
contract Context {
constructor () { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
contract ERC1155Base is Ownable, HasTokenURI, HasContractURI, ERC1155 {
using SafeMath for uint256;
mapping (uint256 => address) public creators;
mapping (uint256 => string) public images;
constructor(string memory contractURI, string memory tokenURIPrefix) HasContractURI(contractURI) HasTokenURI(tokenURIPrefix) {
}
function _mint(uint256 _id, uint256 _supply, string memory _uri, string memory image) internal {
require(<FILL_ME>)
require(_supply != 0, "Supply should be positive");
require(bytes(_uri).length > 0, "uri should be set");
creators[_id] = msg.sender;
images[_id] = image;
balances[_id][msg.sender] = _supply;
_setTokenURI(_id, _uri);
emit TransferSingle(msg.sender, address(0x0), msg.sender, _id, _supply);
emit URI(_uri, _id);
}
function burn(address _owner, uint256 _id, uint256 _value) external {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal override {
}
function setTokenURIPrefix(string memory tokenURIPrefix) public onlyOwner {
}
function setContractURI(string memory contractURI) public onlyOwner {
}
}
contract ShontelleNFT is Ownable, ERC1155Base {
event CreateERC1155_v1(address indexed creator, string name, string symbol);
string public name;
string public symbol;
constructor(string memory _name, string memory _symbol, string memory contractURI, string memory tokenURIPrefix) ERC1155Base(contractURI, tokenURIPrefix) {
}
function mint(uint256 id, uint256 supply, string memory uri, string memory image) onlyOwner public {
}
function batchMint(uint256[] memory _ids, uint256[] memory _quantities, string[] memory uri, string[] memory image) onlyOwner public {
}
}
| creators[_id]==address(0x0),"Token is already minted" | 398,635 | creators[_id]==address(0x0) |
"_setTokenURI: Token should exist" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma experimental ABIEncoderV2;
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 CommonConstants {
bytes4 constant internal ERC1155_ACCEPTED = 0xf23a6e61; // bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))
bytes4 constant internal ERC1155_BATCH_ACCEPTED = 0xbc197c81; // bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))
}
interface ERC1155TokenReceiver {
function onERC1155Received(address _operator, address _from, uint256 _id, uint256 _value, bytes calldata _data) external returns(bytes4);
function onERC1155BatchReceived(address _operator, address _from, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external returns(bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value);
event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event URI(string _value, uint256 indexed _id);
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
function setApprovalForAll(address _operator, bool _approved) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external;
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view returns (uint256[] memory);
}
contract ERC165 is IERC165 {
bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor () {
}
function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
}
function _registerInterface(bytes4 interfaceId) internal {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function toPayable(address account) internal pure returns (address payable) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
}
// A sample implementation of core ERC1155 function.
contract ERC1155 is IERC1155, ERC165, CommonConstants {
using SafeMath for uint256;
using Address for address;
// id => (owner => balance)
mapping (uint256 => mapping(address => uint256)) internal balances;
// owner => (operator => approved)
mapping (address => mapping(address => bool)) internal operatorApproval;
bytes4 constant private INTERFACE_SIGNATURE_ERC1155 = 0xd9b67a26;
constructor() {
}
/////////////////////////////////////////// ERC1155 //////////////////////////////////////////////
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external override{
}
function balanceOf(address _owner, uint256 _id) external view override returns (uint256) {
}
function setApprovalForAll(address _operator, bool _approved) external override {
}
function isApprovedForAll(address _owner, address _operator) external view override returns (bool) {
}
function safeBatchTransferFrom(address _from, address _to, uint256[] calldata _ids, uint256[] calldata _values, bytes calldata _data) external override {
}
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids) external view override returns (uint256[] memory) {
}
function _doSafeTransferAcceptanceCheck(address _operator, address _from, address _to, uint256 _id, uint256 _value, bytes memory _data) internal {
}
function _doSafeBatchTransferAcceptanceCheck(address _operator, address _from, address _to, uint256[] memory _ids, uint256[] memory _values, bytes memory _data) internal {
}
}
library StringLibrary {
function append(string memory _a, string memory _b) internal pure returns (string memory) {
}
function append(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
}
function concat(bytes memory _ba, bytes memory _bb, bytes memory _bc, bytes memory _bd, bytes memory _be, bytes memory _bf, bytes memory _bg) internal pure returns (bytes memory) {
}
}
contract HasContractURI is ERC165 {
string public contractURI;
bytes4 private constant _INTERFACE_ID_CONTRACT_URI = 0xe8a3d485;
constructor(string memory _contractURI) {
}
function _setContractURI(string memory _contractURI) internal {
}
}
contract HasTokenURI {
using StringLibrary for string;
string public tokenURIPrefix;
// Optional mapping for token URIs
mapping(uint256 => string) private _tokenURIs;
constructor(string memory _tokenURIPrefix) {
}
function _tokenURI(uint256 tokenId) internal view returns (string memory) {
}
function _setTokenURI(uint256 tokenId, string memory _uri) internal virtual {
}
function _setTokenURIPrefix(string memory _tokenURIPrefix) internal {
}
function _clearTokenURI(uint256 tokenId) internal {
}
function uri(uint256 _id) external view returns (string memory) {
}
}
contract Context {
constructor () { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function isOwner() public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
contract ERC1155Base is Ownable, HasTokenURI, HasContractURI, ERC1155 {
using SafeMath for uint256;
mapping (uint256 => address) public creators;
mapping (uint256 => string) public images;
constructor(string memory contractURI, string memory tokenURIPrefix) HasContractURI(contractURI) HasTokenURI(tokenURIPrefix) {
}
function _mint(uint256 _id, uint256 _supply, string memory _uri, string memory image) internal {
}
function burn(address _owner, uint256 _id, uint256 _value) external {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal override {
require(<FILL_ME>)
super._setTokenURI(tokenId, uri);
}
function setTokenURIPrefix(string memory tokenURIPrefix) public onlyOwner {
}
function setContractURI(string memory contractURI) public onlyOwner {
}
}
contract ShontelleNFT is Ownable, ERC1155Base {
event CreateERC1155_v1(address indexed creator, string name, string symbol);
string public name;
string public symbol;
constructor(string memory _name, string memory _symbol, string memory contractURI, string memory tokenURIPrefix) ERC1155Base(contractURI, tokenURIPrefix) {
}
function mint(uint256 id, uint256 supply, string memory uri, string memory image) onlyOwner public {
}
function batchMint(uint256[] memory _ids, uint256[] memory _quantities, string[] memory uri, string[] memory image) onlyOwner public {
}
}
| creators[tokenId]!=address(0x0),"_setTokenURI: Token should exist" | 398,635 | creators[tokenId]!=address(0x0) |
"t" | /* solhint-disable func-order */
pragma solidity ^0.4.24;
import "./ERC20.sol";
import "./BimodalLib.sol";
import "./ChallengeLib.sol";
import "./SafeMathLib256.sol";
/**
* This library contains the implementation for the secure commit-chain recovery
* procedure that can be used when the operator of the commit chain is halted by
* the main verifier contract. The methods in this library are only relevant for
* recovering the last confirmed balances of the accounts in the commit chain.
*/
library RecoveryLib {
using SafeMathLib256 for uint256;
using BimodalLib for BimodalLib.Ledger;
function reclaimUncommittedDeposits(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
function reclaimFinalizedWithdrawal(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
/*
* This method can be called without an accompanying proof of exclusive allotment
* to claim only the funds pending in the parent chain.
*/
function recoverOnlyParentChainFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder
)
public
returns (
/* onlyWhenContractPunished() */
uint256 reclaimed
)
{
BimodalLib.Wallet storage wallet = ledger.walletBook[token][holder];
reclaimed = reclaimUncommittedDeposits(ledger, wallet).add(
reclaimFinalizedWithdrawal(ledger, wallet)
);
if (ledger.lastSubmissionEon > 0) {
BimodalLib.AmountAggregate storage eonWithdrawals = ledger
.confirmedWithdrawals[token][ledger
.lastSubmissionEon
.sub(1)
.mod(ledger.EONS_KEPT)];
BimodalLib.addToAggregate(
eonWithdrawals,
ledger.lastSubmissionEon.sub(1),
reclaimed
);
}
if (token != address(this)) {
require(<FILL_ME>)
require(token.transfer(holder, reclaimed), "f");
} else {
holder.transfer(reclaimed);
}
}
/**
* This method requires an accompanying proof of exclusive allotment to claim
*the funds pending in the parent chain along with those exclusively allotted
* in the commit chain.
*/
function recoverAllFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder,
bytes32[2] checksums,
uint64 trail,
bytes32[] allotmentChain,
bytes32[] membershipChain,
uint256[] values,
uint256[2] LR, // solhint-disable func-param-name-mixedcase
uint256[3] dummyPassiveMark
)
public
returns (
/* onlyWhenContractPunished() */
uint256 recovered
)
{
}
}
| ledger.tokenToTrail[token]!=0,"t" | 398,664 | ledger.tokenToTrail[token]!=0 |
"f" | /* solhint-disable func-order */
pragma solidity ^0.4.24;
import "./ERC20.sol";
import "./BimodalLib.sol";
import "./ChallengeLib.sol";
import "./SafeMathLib256.sol";
/**
* This library contains the implementation for the secure commit-chain recovery
* procedure that can be used when the operator of the commit chain is halted by
* the main verifier contract. The methods in this library are only relevant for
* recovering the last confirmed balances of the accounts in the commit chain.
*/
library RecoveryLib {
using SafeMathLib256 for uint256;
using BimodalLib for BimodalLib.Ledger;
function reclaimUncommittedDeposits(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
function reclaimFinalizedWithdrawal(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
/*
* This method can be called without an accompanying proof of exclusive allotment
* to claim only the funds pending in the parent chain.
*/
function recoverOnlyParentChainFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder
)
public
returns (
/* onlyWhenContractPunished() */
uint256 reclaimed
)
{
BimodalLib.Wallet storage wallet = ledger.walletBook[token][holder];
reclaimed = reclaimUncommittedDeposits(ledger, wallet).add(
reclaimFinalizedWithdrawal(ledger, wallet)
);
if (ledger.lastSubmissionEon > 0) {
BimodalLib.AmountAggregate storage eonWithdrawals = ledger
.confirmedWithdrawals[token][ledger
.lastSubmissionEon
.sub(1)
.mod(ledger.EONS_KEPT)];
BimodalLib.addToAggregate(
eonWithdrawals,
ledger.lastSubmissionEon.sub(1),
reclaimed
);
}
if (token != address(this)) {
require(ledger.tokenToTrail[token] != 0, "t");
require(<FILL_ME>)
} else {
holder.transfer(reclaimed);
}
}
/**
* This method requires an accompanying proof of exclusive allotment to claim
*the funds pending in the parent chain along with those exclusively allotted
* in the commit chain.
*/
function recoverAllFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder,
bytes32[2] checksums,
uint64 trail,
bytes32[] allotmentChain,
bytes32[] membershipChain,
uint256[] values,
uint256[2] LR, // solhint-disable func-param-name-mixedcase
uint256[3] dummyPassiveMark
)
public
returns (
/* onlyWhenContractPunished() */
uint256 recovered
)
{
}
}
| token.transfer(holder,reclaimed),"f" | 398,664 | token.transfer(holder,reclaimed) |
"a" | /* solhint-disable func-order */
pragma solidity ^0.4.24;
import "./ERC20.sol";
import "./BimodalLib.sol";
import "./ChallengeLib.sol";
import "./SafeMathLib256.sol";
/**
* This library contains the implementation for the secure commit-chain recovery
* procedure that can be used when the operator of the commit chain is halted by
* the main verifier contract. The methods in this library are only relevant for
* recovering the last confirmed balances of the accounts in the commit chain.
*/
library RecoveryLib {
using SafeMathLib256 for uint256;
using BimodalLib for BimodalLib.Ledger;
function reclaimUncommittedDeposits(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
function reclaimFinalizedWithdrawal(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
/*
* This method can be called without an accompanying proof of exclusive allotment
* to claim only the funds pending in the parent chain.
*/
function recoverOnlyParentChainFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder
)
public
returns (
/* onlyWhenContractPunished() */
uint256 reclaimed
)
{
}
/**
* This method requires an accompanying proof of exclusive allotment to claim
*the funds pending in the parent chain along with those exclusively allotted
* in the commit chain.
*/
function recoverAllFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder,
bytes32[2] checksums,
uint64 trail,
bytes32[] allotmentChain,
bytes32[] membershipChain,
uint256[] values,
uint256[2] LR, // solhint-disable func-param-name-mixedcase
uint256[3] dummyPassiveMark
)
public
returns (
/* onlyWhenContractPunished() */
uint256 recovered
)
{
BimodalLib.Wallet storage wallet = ledger.walletBook[token][holder];
require(<FILL_ME>)
wallet.recovered = true;
recovered = LR[1].sub(LR[0]); // excluslive allotment
recovered = recovered.add(reclaimUncommittedDeposits(ledger, wallet)); // unallotted parent chain deposits
recovered = recovered.add(reclaimFinalizedWithdrawal(ledger, wallet)); // confirmed parent chain withdrawal
if (ledger.lastSubmissionEon > 0) {
dummyPassiveMark[0] = ledger.lastSubmissionEon.sub(1); // confirmedEon
} else {
dummyPassiveMark[0] = 0;
}
require(
ChallengeLib.verifyProofOfExclusiveAccountBalanceAllotment(
ledger,
token,
holder,
checksums,
trail,
dummyPassiveMark, // [confirmedEon, passiveAmount, passiveMark]
allotmentChain,
membershipChain,
values,
LR
),
"p"
);
BimodalLib.AmountAggregate storage eonWithdrawals = ledger
.confirmedWithdrawals[token][dummyPassiveMark[0].mod(
ledger.EONS_KEPT
)];
BimodalLib.addToAggregate(
eonWithdrawals,
dummyPassiveMark[0],
recovered
);
if (token != address(this)) {
require(ledger.tokenToTrail[token] != 0, "t");
require(token.transfer(holder, recovered), "f");
} else {
holder.transfer(recovered);
}
}
}
| !wallet.recovered,"a" | 398,664 | !wallet.recovered |
"p" | /* solhint-disable func-order */
pragma solidity ^0.4.24;
import "./ERC20.sol";
import "./BimodalLib.sol";
import "./ChallengeLib.sol";
import "./SafeMathLib256.sol";
/**
* This library contains the implementation for the secure commit-chain recovery
* procedure that can be used when the operator of the commit chain is halted by
* the main verifier contract. The methods in this library are only relevant for
* recovering the last confirmed balances of the accounts in the commit chain.
*/
library RecoveryLib {
using SafeMathLib256 for uint256;
using BimodalLib for BimodalLib.Ledger;
function reclaimUncommittedDeposits(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
function reclaimFinalizedWithdrawal(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
/*
* This method can be called without an accompanying proof of exclusive allotment
* to claim only the funds pending in the parent chain.
*/
function recoverOnlyParentChainFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder
)
public
returns (
/* onlyWhenContractPunished() */
uint256 reclaimed
)
{
}
/**
* This method requires an accompanying proof of exclusive allotment to claim
*the funds pending in the parent chain along with those exclusively allotted
* in the commit chain.
*/
function recoverAllFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder,
bytes32[2] checksums,
uint64 trail,
bytes32[] allotmentChain,
bytes32[] membershipChain,
uint256[] values,
uint256[2] LR, // solhint-disable func-param-name-mixedcase
uint256[3] dummyPassiveMark
)
public
returns (
/* onlyWhenContractPunished() */
uint256 recovered
)
{
BimodalLib.Wallet storage wallet = ledger.walletBook[token][holder];
require(!wallet.recovered, "a");
wallet.recovered = true;
recovered = LR[1].sub(LR[0]); // excluslive allotment
recovered = recovered.add(reclaimUncommittedDeposits(ledger, wallet)); // unallotted parent chain deposits
recovered = recovered.add(reclaimFinalizedWithdrawal(ledger, wallet)); // confirmed parent chain withdrawal
if (ledger.lastSubmissionEon > 0) {
dummyPassiveMark[0] = ledger.lastSubmissionEon.sub(1); // confirmedEon
} else {
dummyPassiveMark[0] = 0;
}
require(<FILL_ME>)
BimodalLib.AmountAggregate storage eonWithdrawals = ledger
.confirmedWithdrawals[token][dummyPassiveMark[0].mod(
ledger.EONS_KEPT
)];
BimodalLib.addToAggregate(
eonWithdrawals,
dummyPassiveMark[0],
recovered
);
if (token != address(this)) {
require(ledger.tokenToTrail[token] != 0, "t");
require(token.transfer(holder, recovered), "f");
} else {
holder.transfer(recovered);
}
}
}
| ChallengeLib.verifyProofOfExclusiveAccountBalanceAllotment(ledger,token,holder,checksums,trail,dummyPassiveMark,allotmentChain,membershipChain,values,LR),"p" | 398,664 | ChallengeLib.verifyProofOfExclusiveAccountBalanceAllotment(ledger,token,holder,checksums,trail,dummyPassiveMark,allotmentChain,membershipChain,values,LR) |
"f" | /* solhint-disable func-order */
pragma solidity ^0.4.24;
import "./ERC20.sol";
import "./BimodalLib.sol";
import "./ChallengeLib.sol";
import "./SafeMathLib256.sol";
/**
* This library contains the implementation for the secure commit-chain recovery
* procedure that can be used when the operator of the commit chain is halted by
* the main verifier contract. The methods in this library are only relevant for
* recovering the last confirmed balances of the accounts in the commit chain.
*/
library RecoveryLib {
using SafeMathLib256 for uint256;
using BimodalLib for BimodalLib.Ledger;
function reclaimUncommittedDeposits(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
function reclaimFinalizedWithdrawal(
BimodalLib.Ledger storage ledger,
BimodalLib.Wallet storage wallet
) private returns (uint256 amount) {
}
/*
* This method can be called without an accompanying proof of exclusive allotment
* to claim only the funds pending in the parent chain.
*/
function recoverOnlyParentChainFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder
)
public
returns (
/* onlyWhenContractPunished() */
uint256 reclaimed
)
{
}
/**
* This method requires an accompanying proof of exclusive allotment to claim
*the funds pending in the parent chain along with those exclusively allotted
* in the commit chain.
*/
function recoverAllFunds(
BimodalLib.Ledger storage ledger,
ERC20 token,
address holder,
bytes32[2] checksums,
uint64 trail,
bytes32[] allotmentChain,
bytes32[] membershipChain,
uint256[] values,
uint256[2] LR, // solhint-disable func-param-name-mixedcase
uint256[3] dummyPassiveMark
)
public
returns (
/* onlyWhenContractPunished() */
uint256 recovered
)
{
BimodalLib.Wallet storage wallet = ledger.walletBook[token][holder];
require(!wallet.recovered, "a");
wallet.recovered = true;
recovered = LR[1].sub(LR[0]); // excluslive allotment
recovered = recovered.add(reclaimUncommittedDeposits(ledger, wallet)); // unallotted parent chain deposits
recovered = recovered.add(reclaimFinalizedWithdrawal(ledger, wallet)); // confirmed parent chain withdrawal
if (ledger.lastSubmissionEon > 0) {
dummyPassiveMark[0] = ledger.lastSubmissionEon.sub(1); // confirmedEon
} else {
dummyPassiveMark[0] = 0;
}
require(
ChallengeLib.verifyProofOfExclusiveAccountBalanceAllotment(
ledger,
token,
holder,
checksums,
trail,
dummyPassiveMark, // [confirmedEon, passiveAmount, passiveMark]
allotmentChain,
membershipChain,
values,
LR
),
"p"
);
BimodalLib.AmountAggregate storage eonWithdrawals = ledger
.confirmedWithdrawals[token][dummyPassiveMark[0].mod(
ledger.EONS_KEPT
)];
BimodalLib.addToAggregate(
eonWithdrawals,
dummyPassiveMark[0],
recovered
);
if (token != address(this)) {
require(ledger.tokenToTrail[token] != 0, "t");
require(<FILL_ME>)
} else {
holder.transfer(recovered);
}
}
}
| token.transfer(holder,recovered),"f" | 398,664 | token.transfer(holder,recovered) |
"Account is already dev account" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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) private pure returns(bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SHIBCHU is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) private _isDev;
mapping (address => bool) private _isBurn;
address[] private _excluded;
address[] private _dev;
address[] private _burn;
string private constant _NAME = 'Shiba Chulo';
string private constant _SYMBOL = 'SHIBCHU';
uint8 private constant _DECIMALS = 9;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 1000000000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private _tDevTotal;
uint256 private _TAX_FEE = 150; // 1.5% BACK TO HOLDERS
uint256 private _BURN_FEE = 200; // 2% BURNED
uint256 private _DEV_FEE = 150; // 1.5% TO DEV/MARKETING WALLET
uint256 private constant _MAX_TX_SIZE = 10000000000 * _DECIMALFACTOR;
uint256 private ORIG_TAX_FEE = _TAX_FEE;
uint256 private ORIG_BURN_FEE = _BURN_FEE;
uint256 private ORIG_DEV_FEE = _DEV_FEE;
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function isExcluded(address account) public view returns (bool) {
}
function isDev(address account) public view returns (bool) {
}
function totalFees() public view returns (uint256) {
}
function totalBurn() public view returns (uint256) {
}
function totalDev() public view returns (uint256) {
}
function deliver(uint256 tAmount) public {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeAccount(address account) external onlyOwner() {
}
function includeAccount(address account) external onlyOwner() {
}
function setAsDevAccount(address account) external onlyOwner() {
require(<FILL_ME>)
_isDev[account] = true;
_dev.push(account);
}
function setAsBurnAccount(address account) external onlyOwner() {
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
}
function _setDevFee(uint256 devFee) external onlyOwner() {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _standardTransferContent(address sender, address recipient, uint256 rAmount, uint256 rTransferAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _excludedFromTransferContent(address sender, address recipient, uint256 tTransferAmount, uint256 rAmount, uint256 rTransferAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _excludedToTransferContent(address sender, address recipient, uint256 tAmount, uint256 rAmount, uint256 rTransferAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _bothTransferContent(address sender, address recipient, uint256 tAmount, uint256 rAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 rDev, uint256 tFee, uint256 tBurn, uint256 tDev) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTBasics(uint256 tAmount, uint256 taxFee, uint256 burnFee, uint256 devFee) private pure returns (uint256, uint256, uint256) {
}
function getTTransferAmount(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 tDev) private pure returns (uint256) {
}
function _getRBasics(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256) {
}
function _getRTransferAmount(uint256 rAmount, uint256 rFee, uint256 tBurn, uint256 tDev, uint256 currentRate) private pure returns (uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _sendToDev(uint256 tDev, address sender) private {
}
function _sendToBurn(uint256 tBurn, address sender) private {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _getTaxFee() private view returns(uint256) {
}
function _getMaxTxAmount() private pure returns(uint256) {
}
}
| !_isDev[account],"Account is already dev account" | 398,729 | !_isDev[account] |
"Account is already burning account" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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) private pure returns(bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract SHIBCHU is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) private _isDev;
mapping (address => bool) private _isBurn;
address[] private _excluded;
address[] private _dev;
address[] private _burn;
string private constant _NAME = 'Shiba Chulo';
string private constant _SYMBOL = 'SHIBCHU';
uint8 private constant _DECIMALS = 9;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 1000000000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private _tDevTotal;
uint256 private _TAX_FEE = 150; // 1.5% BACK TO HOLDERS
uint256 private _BURN_FEE = 200; // 2% BURNED
uint256 private _DEV_FEE = 150; // 1.5% TO DEV/MARKETING WALLET
uint256 private constant _MAX_TX_SIZE = 10000000000 * _DECIMALFACTOR;
uint256 private ORIG_TAX_FEE = _TAX_FEE;
uint256 private ORIG_BURN_FEE = _BURN_FEE;
uint256 private ORIG_DEV_FEE = _DEV_FEE;
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function isExcluded(address account) public view returns (bool) {
}
function isDev(address account) public view returns (bool) {
}
function totalFees() public view returns (uint256) {
}
function totalBurn() public view returns (uint256) {
}
function totalDev() public view returns (uint256) {
}
function deliver(uint256 tAmount) public {
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function excludeAccount(address account) external onlyOwner() {
}
function includeAccount(address account) external onlyOwner() {
}
function setAsDevAccount(address account) external onlyOwner() {
}
function setAsBurnAccount(address account) external onlyOwner() {
require(<FILL_ME>)
_isBurn[account] = true;
_burn.push(account);
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
}
function _setDevFee(uint256 devFee) external onlyOwner() {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _standardTransferContent(address sender, address recipient, uint256 rAmount, uint256 rTransferAmount) private {
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _excludedFromTransferContent(address sender, address recipient, uint256 tTransferAmount, uint256 rAmount, uint256 rTransferAmount) private {
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _excludedToTransferContent(address sender, address recipient, uint256 tAmount, uint256 rAmount, uint256 rTransferAmount) private {
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
}
function _bothTransferContent(address sender, address recipient, uint256 tAmount, uint256 rAmount, uint256 tTransferAmount, uint256 rTransferAmount) private {
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 rDev, uint256 tFee, uint256 tBurn, uint256 tDev) private {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTBasics(uint256 tAmount, uint256 taxFee, uint256 burnFee, uint256 devFee) private pure returns (uint256, uint256, uint256) {
}
function getTTransferAmount(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 tDev) private pure returns (uint256) {
}
function _getRBasics(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256) {
}
function _getRTransferAmount(uint256 rAmount, uint256 rFee, uint256 tBurn, uint256 tDev, uint256 currentRate) private pure returns (uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function _sendToDev(uint256 tDev, address sender) private {
}
function _sendToBurn(uint256 tBurn, address sender) private {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _getTaxFee() private view returns(uint256) {
}
function _getMaxTxAmount() private pure returns(uint256) {
}
}
| !_isBurn[account],"Account is already burning account" | 398,729 | !_isBurn[account] |
null | contract MultiStageCrowdsale is Ownable {
uint256 public currentStageIndex = 0;
StageCrowdsale[] public stages;
event StageAdded();
function () external payable {
}
modifier hasCurrentStage() {
}
modifier validBuyCall(address _beneficiary) {
}
function addStageCrowdsale(address _stageCrowdsaleAddress) public onlyOwner {
require(_stageCrowdsaleAddress != address(0));
StageCrowdsale stageToBeAdded = StageCrowdsale(_stageCrowdsaleAddress);
if (stages.length > 0) {
require(<FILL_ME>)
StageCrowdsale lastStage = stages[stages.length - 1];
require(stageToBeAdded.openingTime() >= lastStage.closingTime());
}
stages.push(stageToBeAdded);
emit StageAdded();
}
function buyTokens(address _beneficiary) public payable validBuyCall(_beneficiary) hasCurrentStage {
}
function getCurrentStage() public view returns (StageCrowdsale) {
}
function updateCurrentStage() public returns (StageCrowdsale currentStage) {
}
}
| stageToBeAdded.previousStage()!=address(0) | 398,787 | stageToBeAdded.previousStage()!=address(0) |
null | contract MultiStageCrowdsale is Ownable {
uint256 public currentStageIndex = 0;
StageCrowdsale[] public stages;
event StageAdded();
function () external payable {
}
modifier hasCurrentStage() {
}
modifier validBuyCall(address _beneficiary) {
}
function addStageCrowdsale(address _stageCrowdsaleAddress) public onlyOwner {
require(_stageCrowdsaleAddress != address(0));
StageCrowdsale stageToBeAdded = StageCrowdsale(_stageCrowdsaleAddress);
if (stages.length > 0) {
require(stageToBeAdded.previousStage() != address(0));
StageCrowdsale lastStage = stages[stages.length - 1];
require(<FILL_ME>)
}
stages.push(stageToBeAdded);
emit StageAdded();
}
function buyTokens(address _beneficiary) public payable validBuyCall(_beneficiary) hasCurrentStage {
}
function getCurrentStage() public view returns (StageCrowdsale) {
}
function updateCurrentStage() public returns (StageCrowdsale currentStage) {
}
}
| stageToBeAdded.openingTime()>=lastStage.closingTime() | 398,787 | stageToBeAdded.openingTime()>=lastStage.closingTime() |
"Requested value exceeds maximum value for Titans." | // ROGUE TITANS
//
// MMMMMMXk;.;xXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNk:':kNMMMMMM
// MMWXkl;. .,lkKWMMMMMMMMMMMMMMMMMMMMMMMMMMWXko;. .;oOXWMM
// 0xc'. ..:d0NMMMMMMMMMMMMMMMMMMMMN0xc'. .'cxK
// . .,lkXWMMMMMMMMMMMMWXOo;. .
// .'cx0NMMMMMMWKxc'.
// .:kNNKOo;.
// ;dc'. .,cllc'.. ..:o;
// .lNWXOo;. .;clc;. .,lkXWNl.
// .lNMMMMN0dlllc,. ..:d0NMMMMWl.
// .lNMMMMN0d:.. .,cllld0NMMMMNl.
// .lNWXkl,. .;llc;.. .;okXWNl.
// ;o:.. .,;cllc,. .'cd;
// .;oONWNk:.
// .'cxKWMMMMMMN0xc'.
// . .;oOXWMMMMMMMMMMMMWXkl,. .
// Kxc'. .'cxKWMMMMMMMMMMMMMMMMMMMMN0d:.. .'cd0
// MMWXOo;. .;oOXWMMMMMMMMMMMMMMMMMMMMMMMMMMWXkl,. .,lkXWMM
// MMMMMMNk:':kXMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWXx;.:kXMMMMMM
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
contract Titan is ERC721URIStorage, ReentrancyGuard, Ownable {
event Activate();
event Deactivate();
event ActivatePresale();
event DeactivatePresale();
event Initialize();
string public baseURI;
bool public isSaleActive = false;
// For epilogue usage
uint256 constant public maxEpilogueMints = 10;
uint256 public epiloguePointer = 0;
// Airdrop mint parameters
uint256 constant public maxAirdropTitans = 110;
uint256 public numAirdroppedTitans = 0;
// Standard mint parameters
uint256 constant public maxTitans = 5555;
uint256 public numMintedTitans = maxEpilogueMints;
uint256 constant private mintPrice = 0.05 ether;
uint16 constant private maxTitansPerMint = 5;
// Whitelisted presale parameters
bool public isWhitelistSaleActive = false;
mapping (address => bool) public whitelistedWallets;
constructor() ERC721("Rogue Titan", "TITAN") {
}
// Set a base URI
function updateBaseURI(string memory baseURI_) public onlyOwner {
}
// Get the base URI
function _baseURI() internal view override returns (string memory) {
}
// To be used to originally initliaze
function initializeSale(string memory baseURI_) public onlyOwner {
}
// Toggle the main sale
function toggleSale() public onlyOwner {
}
// Toggle the whitelist presale
function togglePresale() public onlyOwner {
}
// Withdraw balance
function withdrawBalance() public onlyOwner {
}
// Community mint for Titans
function mintTitan(uint256 _numTitansToMint) external payable nonReentrant {
require(isSaleActive, "Titans are not available to mint at this time.");
require(_numTitansToMint > 0 && _numTitansToMint <= maxTitansPerMint, "You must mint between 1 and 5 Titans at a time.");
require(<FILL_ME>)
require(msg.value >= (_numTitansToMint * mintPrice), "Invalid amount of ETH sent.");
if (isWhitelistSaleActive) {
require(isAddressWhitelisted(msg.sender), "This address is not whitelisted for the presale.");
}
for (uint i = 0; i < _numTitansToMint; i++) {
numMintedTitans++;
_safeMint(msg.sender, numMintedTitans);
}
}
// Owner airdrop for Titans
function airdropTitans(address[] memory _airdropAddresses) external onlyOwner nonReentrant {
}
// Add address' to the whitelist
function addWhitelistAddresses(address[] memory _addresses) public onlyOwner {
}
// Internal usage to verify address against whitelist
function isAddressWhitelisted(address _address) public view returns (bool) {
}
// For Epilogue usage only
function mintEpilogueTitans(uint256 _numToMint) public onlyOwner nonReentrant {
}
}
| (numMintedTitans+_numTitansToMint)<=(maxTitans-maxAirdropTitans),"Requested value exceeds maximum value for Titans." | 398,793 | (numMintedTitans+_numTitansToMint)<=(maxTitans-maxAirdropTitans) |
"Invalid amount of ETH sent." | // ROGUE TITANS
//
// MMMMMMXk;.;xXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNk:':kNMMMMMM
// MMWXkl;. .,lkKWMMMMMMMMMMMMMMMMMMMMMMMMMMWXko;. .;oOXWMM
// 0xc'. ..:d0NMMMMMMMMMMMMMMMMMMMMN0xc'. .'cxK
// . .,lkXWMMMMMMMMMMMMWXOo;. .
// .'cx0NMMMMMMWKxc'.
// .:kNNKOo;.
// ;dc'. .,cllc'.. ..:o;
// .lNWXOo;. .;clc;. .,lkXWNl.
// .lNMMMMN0dlllc,. ..:d0NMMMMWl.
// .lNMMMMN0d:.. .,cllld0NMMMMNl.
// .lNWXkl,. .;llc;.. .;okXWNl.
// ;o:.. .,;cllc,. .'cd;
// .;oONWNk:.
// .'cxKWMMMMMMN0xc'.
// . .;oOXWMMMMMMMMMMMMWXkl,. .
// Kxc'. .'cxKWMMMMMMMMMMMMMMMMMMMMN0d:.. .'cd0
// MMWXOo;. .;oOXWMMMMMMMMMMMMMMMMMMMMMMMMMMWXkl,. .,lkXWMM
// MMMMMMNk:':kXMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWXx;.:kXMMMMMM
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
contract Titan is ERC721URIStorage, ReentrancyGuard, Ownable {
event Activate();
event Deactivate();
event ActivatePresale();
event DeactivatePresale();
event Initialize();
string public baseURI;
bool public isSaleActive = false;
// For epilogue usage
uint256 constant public maxEpilogueMints = 10;
uint256 public epiloguePointer = 0;
// Airdrop mint parameters
uint256 constant public maxAirdropTitans = 110;
uint256 public numAirdroppedTitans = 0;
// Standard mint parameters
uint256 constant public maxTitans = 5555;
uint256 public numMintedTitans = maxEpilogueMints;
uint256 constant private mintPrice = 0.05 ether;
uint16 constant private maxTitansPerMint = 5;
// Whitelisted presale parameters
bool public isWhitelistSaleActive = false;
mapping (address => bool) public whitelistedWallets;
constructor() ERC721("Rogue Titan", "TITAN") {
}
// Set a base URI
function updateBaseURI(string memory baseURI_) public onlyOwner {
}
// Get the base URI
function _baseURI() internal view override returns (string memory) {
}
// To be used to originally initliaze
function initializeSale(string memory baseURI_) public onlyOwner {
}
// Toggle the main sale
function toggleSale() public onlyOwner {
}
// Toggle the whitelist presale
function togglePresale() public onlyOwner {
}
// Withdraw balance
function withdrawBalance() public onlyOwner {
}
// Community mint for Titans
function mintTitan(uint256 _numTitansToMint) external payable nonReentrant {
require(isSaleActive, "Titans are not available to mint at this time.");
require(_numTitansToMint > 0 && _numTitansToMint <= maxTitansPerMint, "You must mint between 1 and 5 Titans at a time.");
require((numMintedTitans + _numTitansToMint) <= (maxTitans - maxAirdropTitans), "Requested value exceeds maximum value for Titans.");
require(<FILL_ME>)
if (isWhitelistSaleActive) {
require(isAddressWhitelisted(msg.sender), "This address is not whitelisted for the presale.");
}
for (uint i = 0; i < _numTitansToMint; i++) {
numMintedTitans++;
_safeMint(msg.sender, numMintedTitans);
}
}
// Owner airdrop for Titans
function airdropTitans(address[] memory _airdropAddresses) external onlyOwner nonReentrant {
}
// Add address' to the whitelist
function addWhitelistAddresses(address[] memory _addresses) public onlyOwner {
}
// Internal usage to verify address against whitelist
function isAddressWhitelisted(address _address) public view returns (bool) {
}
// For Epilogue usage only
function mintEpilogueTitans(uint256 _numToMint) public onlyOwner nonReentrant {
}
}
| msg.value>=(_numTitansToMint*mintPrice),"Invalid amount of ETH sent." | 398,793 | msg.value>=(_numTitansToMint*mintPrice) |
"Requested value exceeds maximum value for Airdrop Titans." | // ROGUE TITANS
//
// MMMMMMXk;.;xXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNk:':kNMMMMMM
// MMWXkl;. .,lkKWMMMMMMMMMMMMMMMMMMMMMMMMMMWXko;. .;oOXWMM
// 0xc'. ..:d0NMMMMMMMMMMMMMMMMMMMMN0xc'. .'cxK
// . .,lkXWMMMMMMMMMMMMWXOo;. .
// .'cx0NMMMMMMWKxc'.
// .:kNNKOo;.
// ;dc'. .,cllc'.. ..:o;
// .lNWXOo;. .;clc;. .,lkXWNl.
// .lNMMMMN0dlllc,. ..:d0NMMMMWl.
// .lNMMMMN0d:.. .,cllld0NMMMMNl.
// .lNWXkl,. .;llc;.. .;okXWNl.
// ;o:.. .,;cllc,. .'cd;
// .;oONWNk:.
// .'cxKWMMMMMMN0xc'.
// . .;oOXWMMMMMMMMMMMMWXkl,. .
// Kxc'. .'cxKWMMMMMMMMMMMMMMMMMMMMN0d:.. .'cd0
// MMWXOo;. .;oOXWMMMMMMMMMMMMMMMMMMMMMMMMMMWXkl,. .,lkXWMM
// MMMMMMNk:':kXMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWXx;.:kXMMMMMM
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
contract Titan is ERC721URIStorage, ReentrancyGuard, Ownable {
event Activate();
event Deactivate();
event ActivatePresale();
event DeactivatePresale();
event Initialize();
string public baseURI;
bool public isSaleActive = false;
// For epilogue usage
uint256 constant public maxEpilogueMints = 10;
uint256 public epiloguePointer = 0;
// Airdrop mint parameters
uint256 constant public maxAirdropTitans = 110;
uint256 public numAirdroppedTitans = 0;
// Standard mint parameters
uint256 constant public maxTitans = 5555;
uint256 public numMintedTitans = maxEpilogueMints;
uint256 constant private mintPrice = 0.05 ether;
uint16 constant private maxTitansPerMint = 5;
// Whitelisted presale parameters
bool public isWhitelistSaleActive = false;
mapping (address => bool) public whitelistedWallets;
constructor() ERC721("Rogue Titan", "TITAN") {
}
// Set a base URI
function updateBaseURI(string memory baseURI_) public onlyOwner {
}
// Get the base URI
function _baseURI() internal view override returns (string memory) {
}
// To be used to originally initliaze
function initializeSale(string memory baseURI_) public onlyOwner {
}
// Toggle the main sale
function toggleSale() public onlyOwner {
}
// Toggle the whitelist presale
function togglePresale() public onlyOwner {
}
// Withdraw balance
function withdrawBalance() public onlyOwner {
}
// Community mint for Titans
function mintTitan(uint256 _numTitansToMint) external payable nonReentrant {
}
// Owner airdrop for Titans
function airdropTitans(address[] memory _airdropAddresses) external onlyOwner nonReentrant {
require(<FILL_ME>)
for (uint256 i = 0; i < _airdropAddresses.length; i++) {
numAirdroppedTitans++;
numMintedTitans++;
_safeMint(_airdropAddresses[i], numMintedTitans);
}
}
// Add address' to the whitelist
function addWhitelistAddresses(address[] memory _addresses) public onlyOwner {
}
// Internal usage to verify address against whitelist
function isAddressWhitelisted(address _address) public view returns (bool) {
}
// For Epilogue usage only
function mintEpilogueTitans(uint256 _numToMint) public onlyOwner nonReentrant {
}
}
| (numAirdroppedTitans+_airdropAddresses.length)<=maxAirdropTitans,"Requested value exceeds maximum value for Airdrop Titans." | 398,793 | (numAirdroppedTitans+_airdropAddresses.length)<=maxAirdropTitans |
"Requested value exceeds maximum value for Epilogue Titans." | // ROGUE TITANS
//
// MMMMMMXk;.;xXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNk:':kNMMMMMM
// MMWXkl;. .,lkKWMMMMMMMMMMMMMMMMMMMMMMMMMMWXko;. .;oOXWMM
// 0xc'. ..:d0NMMMMMMMMMMMMMMMMMMMMN0xc'. .'cxK
// . .,lkXWMMMMMMMMMMMMWXOo;. .
// .'cx0NMMMMMMWKxc'.
// .:kNNKOo;.
// ;dc'. .,cllc'.. ..:o;
// .lNWXOo;. .;clc;. .,lkXWNl.
// .lNMMMMN0dlllc,. ..:d0NMMMMWl.
// .lNMMMMN0d:.. .,cllld0NMMMMNl.
// .lNWXkl,. .;llc;.. .;okXWNl.
// ;o:.. .,;cllc,. .'cd;
// .;oONWNk:.
// .'cxKWMMMMMMN0xc'.
// . .;oOXWMMMMMMMMMMMMWXkl,. .
// Kxc'. .'cxKWMMMMMMMMMMMMMMMMMMMMN0d:.. .'cd0
// MMWXOo;. .;oOXWMMMMMMMMMMMMMMMMMMMMMMMMMMWXkl,. .,lkXWMM
// MMMMMMNk:':kXMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWXx;.:kXMMMMMM
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
contract Titan is ERC721URIStorage, ReentrancyGuard, Ownable {
event Activate();
event Deactivate();
event ActivatePresale();
event DeactivatePresale();
event Initialize();
string public baseURI;
bool public isSaleActive = false;
// For epilogue usage
uint256 constant public maxEpilogueMints = 10;
uint256 public epiloguePointer = 0;
// Airdrop mint parameters
uint256 constant public maxAirdropTitans = 110;
uint256 public numAirdroppedTitans = 0;
// Standard mint parameters
uint256 constant public maxTitans = 5555;
uint256 public numMintedTitans = maxEpilogueMints;
uint256 constant private mintPrice = 0.05 ether;
uint16 constant private maxTitansPerMint = 5;
// Whitelisted presale parameters
bool public isWhitelistSaleActive = false;
mapping (address => bool) public whitelistedWallets;
constructor() ERC721("Rogue Titan", "TITAN") {
}
// Set a base URI
function updateBaseURI(string memory baseURI_) public onlyOwner {
}
// Get the base URI
function _baseURI() internal view override returns (string memory) {
}
// To be used to originally initliaze
function initializeSale(string memory baseURI_) public onlyOwner {
}
// Toggle the main sale
function toggleSale() public onlyOwner {
}
// Toggle the whitelist presale
function togglePresale() public onlyOwner {
}
// Withdraw balance
function withdrawBalance() public onlyOwner {
}
// Community mint for Titans
function mintTitan(uint256 _numTitansToMint) external payable nonReentrant {
}
// Owner airdrop for Titans
function airdropTitans(address[] memory _airdropAddresses) external onlyOwner nonReentrant {
}
// Add address' to the whitelist
function addWhitelistAddresses(address[] memory _addresses) public onlyOwner {
}
// Internal usage to verify address against whitelist
function isAddressWhitelisted(address _address) public view returns (bool) {
}
// For Epilogue usage only
function mintEpilogueTitans(uint256 _numToMint) public onlyOwner nonReentrant {
require(<FILL_ME>)
for (uint i = 0; i < _numToMint; i++) {
epiloguePointer++;
_safeMint(msg.sender, epiloguePointer);
}
}
}
| (epiloguePointer+_numToMint)<=(maxEpilogueMints),"Requested value exceeds maximum value for Epilogue Titans." | 398,793 | (epiloguePointer+_numToMint)<=(maxEpilogueMints) |
'All tokens have been minted' | pragma solidity ^0.8.2;
contract AnimeGangSpecial is ERC721, Ownable, ERC721Enumerable {
using SafeMath for uint256;
using Counters for Counters.Counter;
string public _baseTokenURI;
Counters.Counter private supply;
uint256 public AIRDROP_SUPPLY = 200;
constructor(string memory name,
string memory symbol,
string memory baseTokenURI) ERC721(name, symbol)
{
}
function changeState(uint256 supplyOfAirDrop) external onlyOwner {
}
function mintAirdrop(address[] calldata winners) external onlyOwner {
require(<FILL_ME>)
require(supply.current() + winners.length <= AIRDROP_SUPPLY, 'Not enough tokens left to gift');
for (uint256 i = 0; i < winners.length; i++) {
supply.increment();
_safeMint(winners[i], supply.current());
}
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| totalSupply()<=AIRDROP_SUPPLY,'All tokens have been minted' | 398,850 | totalSupply()<=AIRDROP_SUPPLY |
'Not enough tokens left to gift' | pragma solidity ^0.8.2;
contract AnimeGangSpecial is ERC721, Ownable, ERC721Enumerable {
using SafeMath for uint256;
using Counters for Counters.Counter;
string public _baseTokenURI;
Counters.Counter private supply;
uint256 public AIRDROP_SUPPLY = 200;
constructor(string memory name,
string memory symbol,
string memory baseTokenURI) ERC721(name, symbol)
{
}
function changeState(uint256 supplyOfAirDrop) external onlyOwner {
}
function mintAirdrop(address[] calldata winners) external onlyOwner {
require(totalSupply() <= AIRDROP_SUPPLY, 'All tokens have been minted');
require(<FILL_ME>)
for (uint256 i = 0; i < winners.length; i++) {
supply.increment();
_safeMint(winners[i], supply.current());
}
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
}
}
| supply.current()+winners.length<=AIRDROP_SUPPLY,'Not enough tokens left to gift' | 398,850 | supply.current()+winners.length<=AIRDROP_SUPPLY |
"not enough eth" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract CandyHunters is
ERC721A,
Ownable
{
using ECDSA for bytes32;
enum alTypes {FREE, PAID}
mapping (address => uint256) public alClaims;
mapping (address => uint256) public freeClaims;
uint256 public constant teamSupply = 100;
uint256 public constant maxSupply = 10000;
uint256 public constant allowlistMintPrice2 = 0.05 ether;
uint256 public constant allowlistMintPrice3 = 0.04 ether;
uint256 public constant publicMintPrice = 0.06 ether;
uint256 public maxPerTx = 5;
uint256 public teamClaimCount = 0;
address public signerAddress = 0x7E4723A50108AC20CBE09cD9F656bd065f5B42c8;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address private _manager = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM1 = 0x45acf055d977D8EA41AF353D16D7ba83F9B79bd7;
address private TEAM2 = 0x723B5cB2b5F86660d5b8391d847DB40eeA34bf7c;
address private TEAM3 = 0x9a2197620d3268bA57bfb822Ebc0cEA7105cbA94;
address private TEAM4 = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM5 = 0x8cc1B927E8691F825D213E1f404BCCbF9AA08490;
address private TEAM6 = 0x0B5063760d05b151418d7D8B6947C5d81649c6C6;
address private COMMUNITY_FUND = 0x01402DAebB58062FDbD76A378789e3Fa5F009196;
address private SECONDARY_FUND = 0x08c239fCE14d628b891B8882ED60733F6aDF5B3A;
string public baseUri = "https://mint.candyhuntersnft.io/api/token/";
string public endingUri = ".json";
bool public allowlistActive = false;
bool public publicActive = false;
constructor () ERC721A("Candy Hunters", "CANDY") {
}
receive() external payable {}
modifier onlyOwnerOrManager() {
}
function _startTokenId() internal pure override(ERC721A) returns(uint256 startId) {
}
function flipPublicSaleState() public onlyOwnerOrManager {
}
function flipAllowlistSaleState() public onlyOwnerOrManager {
}
function setManager(address manager) external onlyOwnerOrManager {
}
function setProxyRegistry(address preg) external onlyOwnerOrManager {
}
function setSignerAddress(address signer) external onlyOwnerOrManager {
}
function setBaseURI(string memory _URI) external onlyOwnerOrManager {
}
function setEndingURI(string memory _URI) external onlyOwnerOrManager {
}
function withdrawBackup() external onlyOwnerOrManager {
}
function withdrawAll() external onlyOwnerOrManager {
}
function _withdraw(address _address, uint256 _amount) private {
}
function _hash(address _address, uint256 quantity, uint256 alType) internal view returns (bytes32) {
}
function _verify( bytes memory signature, uint256 quantity, uint256 alType) internal view returns (bool) {
}
function publicMint(uint256 amount) external payable {
require(publicActive, "not live");
require(amount <= maxPerTx, "too many");
require(msg.sender == tx.origin, "no bots");
require(totalSupply() + amount <= maxSupply , "sold out");
require(<FILL_ME>)
_safeMint(msg.sender, amount);
}
function allowlistMint( uint256 amount, uint256 maxAmount, bytes calldata _signature) external payable{
}
function freeMint(uint256 amount, uint256 maxAmount, bytes calldata _signature) external{
}
function teamMint(uint256 amount, address _to) external onlyOwnerOrManager {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| publicMintPrice*amount==msg.value,"not enough eth" | 398,925 | publicMintPrice*amount==msg.value |
"bad signature" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract CandyHunters is
ERC721A,
Ownable
{
using ECDSA for bytes32;
enum alTypes {FREE, PAID}
mapping (address => uint256) public alClaims;
mapping (address => uint256) public freeClaims;
uint256 public constant teamSupply = 100;
uint256 public constant maxSupply = 10000;
uint256 public constant allowlistMintPrice2 = 0.05 ether;
uint256 public constant allowlistMintPrice3 = 0.04 ether;
uint256 public constant publicMintPrice = 0.06 ether;
uint256 public maxPerTx = 5;
uint256 public teamClaimCount = 0;
address public signerAddress = 0x7E4723A50108AC20CBE09cD9F656bd065f5B42c8;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address private _manager = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM1 = 0x45acf055d977D8EA41AF353D16D7ba83F9B79bd7;
address private TEAM2 = 0x723B5cB2b5F86660d5b8391d847DB40eeA34bf7c;
address private TEAM3 = 0x9a2197620d3268bA57bfb822Ebc0cEA7105cbA94;
address private TEAM4 = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM5 = 0x8cc1B927E8691F825D213E1f404BCCbF9AA08490;
address private TEAM6 = 0x0B5063760d05b151418d7D8B6947C5d81649c6C6;
address private COMMUNITY_FUND = 0x01402DAebB58062FDbD76A378789e3Fa5F009196;
address private SECONDARY_FUND = 0x08c239fCE14d628b891B8882ED60733F6aDF5B3A;
string public baseUri = "https://mint.candyhuntersnft.io/api/token/";
string public endingUri = ".json";
bool public allowlistActive = false;
bool public publicActive = false;
constructor () ERC721A("Candy Hunters", "CANDY") {
}
receive() external payable {}
modifier onlyOwnerOrManager() {
}
function _startTokenId() internal pure override(ERC721A) returns(uint256 startId) {
}
function flipPublicSaleState() public onlyOwnerOrManager {
}
function flipAllowlistSaleState() public onlyOwnerOrManager {
}
function setManager(address manager) external onlyOwnerOrManager {
}
function setProxyRegistry(address preg) external onlyOwnerOrManager {
}
function setSignerAddress(address signer) external onlyOwnerOrManager {
}
function setBaseURI(string memory _URI) external onlyOwnerOrManager {
}
function setEndingURI(string memory _URI) external onlyOwnerOrManager {
}
function withdrawBackup() external onlyOwnerOrManager {
}
function withdrawAll() external onlyOwnerOrManager {
}
function _withdraw(address _address, uint256 _amount) private {
}
function _hash(address _address, uint256 quantity, uint256 alType) internal view returns (bytes32) {
}
function _verify( bytes memory signature, uint256 quantity, uint256 alType) internal view returns (bool) {
}
function publicMint(uint256 amount) external payable {
}
function allowlistMint( uint256 amount, uint256 maxAmount, bytes calldata _signature) external payable{
require(allowlistActive, "not live");
require(totalSupply() + amount <= maxSupply , "sold out");
require(<FILL_ME>)
require(alClaims[msg.sender] + amount <= maxAmount, "max used");
if (maxAmount == 3){
require(allowlistMintPrice3 * amount == msg.value, "not enough eth");
} else {
require(allowlistMintPrice2 * amount == msg.value, "not enough eth");
}
alClaims[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function freeMint(uint256 amount, uint256 maxAmount, bytes calldata _signature) external{
}
function teamMint(uint256 amount, address _to) external onlyOwnerOrManager {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| _verify(_signature,maxAmount,uint(alTypes.PAID)),"bad signature" | 398,925 | _verify(_signature,maxAmount,uint(alTypes.PAID)) |
"max used" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract CandyHunters is
ERC721A,
Ownable
{
using ECDSA for bytes32;
enum alTypes {FREE, PAID}
mapping (address => uint256) public alClaims;
mapping (address => uint256) public freeClaims;
uint256 public constant teamSupply = 100;
uint256 public constant maxSupply = 10000;
uint256 public constant allowlistMintPrice2 = 0.05 ether;
uint256 public constant allowlistMintPrice3 = 0.04 ether;
uint256 public constant publicMintPrice = 0.06 ether;
uint256 public maxPerTx = 5;
uint256 public teamClaimCount = 0;
address public signerAddress = 0x7E4723A50108AC20CBE09cD9F656bd065f5B42c8;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address private _manager = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM1 = 0x45acf055d977D8EA41AF353D16D7ba83F9B79bd7;
address private TEAM2 = 0x723B5cB2b5F86660d5b8391d847DB40eeA34bf7c;
address private TEAM3 = 0x9a2197620d3268bA57bfb822Ebc0cEA7105cbA94;
address private TEAM4 = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM5 = 0x8cc1B927E8691F825D213E1f404BCCbF9AA08490;
address private TEAM6 = 0x0B5063760d05b151418d7D8B6947C5d81649c6C6;
address private COMMUNITY_FUND = 0x01402DAebB58062FDbD76A378789e3Fa5F009196;
address private SECONDARY_FUND = 0x08c239fCE14d628b891B8882ED60733F6aDF5B3A;
string public baseUri = "https://mint.candyhuntersnft.io/api/token/";
string public endingUri = ".json";
bool public allowlistActive = false;
bool public publicActive = false;
constructor () ERC721A("Candy Hunters", "CANDY") {
}
receive() external payable {}
modifier onlyOwnerOrManager() {
}
function _startTokenId() internal pure override(ERC721A) returns(uint256 startId) {
}
function flipPublicSaleState() public onlyOwnerOrManager {
}
function flipAllowlistSaleState() public onlyOwnerOrManager {
}
function setManager(address manager) external onlyOwnerOrManager {
}
function setProxyRegistry(address preg) external onlyOwnerOrManager {
}
function setSignerAddress(address signer) external onlyOwnerOrManager {
}
function setBaseURI(string memory _URI) external onlyOwnerOrManager {
}
function setEndingURI(string memory _URI) external onlyOwnerOrManager {
}
function withdrawBackup() external onlyOwnerOrManager {
}
function withdrawAll() external onlyOwnerOrManager {
}
function _withdraw(address _address, uint256 _amount) private {
}
function _hash(address _address, uint256 quantity, uint256 alType) internal view returns (bytes32) {
}
function _verify( bytes memory signature, uint256 quantity, uint256 alType) internal view returns (bool) {
}
function publicMint(uint256 amount) external payable {
}
function allowlistMint( uint256 amount, uint256 maxAmount, bytes calldata _signature) external payable{
require(allowlistActive, "not live");
require(totalSupply() + amount <= maxSupply , "sold out");
require(_verify(_signature, maxAmount, uint(alTypes.PAID)), "bad signature");
require(<FILL_ME>)
if (maxAmount == 3){
require(allowlistMintPrice3 * amount == msg.value, "not enough eth");
} else {
require(allowlistMintPrice2 * amount == msg.value, "not enough eth");
}
alClaims[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function freeMint(uint256 amount, uint256 maxAmount, bytes calldata _signature) external{
}
function teamMint(uint256 amount, address _to) external onlyOwnerOrManager {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| alClaims[msg.sender]+amount<=maxAmount,"max used" | 398,925 | alClaims[msg.sender]+amount<=maxAmount |
"not enough eth" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract CandyHunters is
ERC721A,
Ownable
{
using ECDSA for bytes32;
enum alTypes {FREE, PAID}
mapping (address => uint256) public alClaims;
mapping (address => uint256) public freeClaims;
uint256 public constant teamSupply = 100;
uint256 public constant maxSupply = 10000;
uint256 public constant allowlistMintPrice2 = 0.05 ether;
uint256 public constant allowlistMintPrice3 = 0.04 ether;
uint256 public constant publicMintPrice = 0.06 ether;
uint256 public maxPerTx = 5;
uint256 public teamClaimCount = 0;
address public signerAddress = 0x7E4723A50108AC20CBE09cD9F656bd065f5B42c8;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address private _manager = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM1 = 0x45acf055d977D8EA41AF353D16D7ba83F9B79bd7;
address private TEAM2 = 0x723B5cB2b5F86660d5b8391d847DB40eeA34bf7c;
address private TEAM3 = 0x9a2197620d3268bA57bfb822Ebc0cEA7105cbA94;
address private TEAM4 = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM5 = 0x8cc1B927E8691F825D213E1f404BCCbF9AA08490;
address private TEAM6 = 0x0B5063760d05b151418d7D8B6947C5d81649c6C6;
address private COMMUNITY_FUND = 0x01402DAebB58062FDbD76A378789e3Fa5F009196;
address private SECONDARY_FUND = 0x08c239fCE14d628b891B8882ED60733F6aDF5B3A;
string public baseUri = "https://mint.candyhuntersnft.io/api/token/";
string public endingUri = ".json";
bool public allowlistActive = false;
bool public publicActive = false;
constructor () ERC721A("Candy Hunters", "CANDY") {
}
receive() external payable {}
modifier onlyOwnerOrManager() {
}
function _startTokenId() internal pure override(ERC721A) returns(uint256 startId) {
}
function flipPublicSaleState() public onlyOwnerOrManager {
}
function flipAllowlistSaleState() public onlyOwnerOrManager {
}
function setManager(address manager) external onlyOwnerOrManager {
}
function setProxyRegistry(address preg) external onlyOwnerOrManager {
}
function setSignerAddress(address signer) external onlyOwnerOrManager {
}
function setBaseURI(string memory _URI) external onlyOwnerOrManager {
}
function setEndingURI(string memory _URI) external onlyOwnerOrManager {
}
function withdrawBackup() external onlyOwnerOrManager {
}
function withdrawAll() external onlyOwnerOrManager {
}
function _withdraw(address _address, uint256 _amount) private {
}
function _hash(address _address, uint256 quantity, uint256 alType) internal view returns (bytes32) {
}
function _verify( bytes memory signature, uint256 quantity, uint256 alType) internal view returns (bool) {
}
function publicMint(uint256 amount) external payable {
}
function allowlistMint( uint256 amount, uint256 maxAmount, bytes calldata _signature) external payable{
require(allowlistActive, "not live");
require(totalSupply() + amount <= maxSupply , "sold out");
require(_verify(_signature, maxAmount, uint(alTypes.PAID)), "bad signature");
require(alClaims[msg.sender] + amount <= maxAmount, "max used");
if (maxAmount == 3){
require(<FILL_ME>)
} else {
require(allowlistMintPrice2 * amount == msg.value, "not enough eth");
}
alClaims[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function freeMint(uint256 amount, uint256 maxAmount, bytes calldata _signature) external{
}
function teamMint(uint256 amount, address _to) external onlyOwnerOrManager {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| allowlistMintPrice3*amount==msg.value,"not enough eth" | 398,925 | allowlistMintPrice3*amount==msg.value |
"not enough eth" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract CandyHunters is
ERC721A,
Ownable
{
using ECDSA for bytes32;
enum alTypes {FREE, PAID}
mapping (address => uint256) public alClaims;
mapping (address => uint256) public freeClaims;
uint256 public constant teamSupply = 100;
uint256 public constant maxSupply = 10000;
uint256 public constant allowlistMintPrice2 = 0.05 ether;
uint256 public constant allowlistMintPrice3 = 0.04 ether;
uint256 public constant publicMintPrice = 0.06 ether;
uint256 public maxPerTx = 5;
uint256 public teamClaimCount = 0;
address public signerAddress = 0x7E4723A50108AC20CBE09cD9F656bd065f5B42c8;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address private _manager = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM1 = 0x45acf055d977D8EA41AF353D16D7ba83F9B79bd7;
address private TEAM2 = 0x723B5cB2b5F86660d5b8391d847DB40eeA34bf7c;
address private TEAM3 = 0x9a2197620d3268bA57bfb822Ebc0cEA7105cbA94;
address private TEAM4 = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM5 = 0x8cc1B927E8691F825D213E1f404BCCbF9AA08490;
address private TEAM6 = 0x0B5063760d05b151418d7D8B6947C5d81649c6C6;
address private COMMUNITY_FUND = 0x01402DAebB58062FDbD76A378789e3Fa5F009196;
address private SECONDARY_FUND = 0x08c239fCE14d628b891B8882ED60733F6aDF5B3A;
string public baseUri = "https://mint.candyhuntersnft.io/api/token/";
string public endingUri = ".json";
bool public allowlistActive = false;
bool public publicActive = false;
constructor () ERC721A("Candy Hunters", "CANDY") {
}
receive() external payable {}
modifier onlyOwnerOrManager() {
}
function _startTokenId() internal pure override(ERC721A) returns(uint256 startId) {
}
function flipPublicSaleState() public onlyOwnerOrManager {
}
function flipAllowlistSaleState() public onlyOwnerOrManager {
}
function setManager(address manager) external onlyOwnerOrManager {
}
function setProxyRegistry(address preg) external onlyOwnerOrManager {
}
function setSignerAddress(address signer) external onlyOwnerOrManager {
}
function setBaseURI(string memory _URI) external onlyOwnerOrManager {
}
function setEndingURI(string memory _URI) external onlyOwnerOrManager {
}
function withdrawBackup() external onlyOwnerOrManager {
}
function withdrawAll() external onlyOwnerOrManager {
}
function _withdraw(address _address, uint256 _amount) private {
}
function _hash(address _address, uint256 quantity, uint256 alType) internal view returns (bytes32) {
}
function _verify( bytes memory signature, uint256 quantity, uint256 alType) internal view returns (bool) {
}
function publicMint(uint256 amount) external payable {
}
function allowlistMint( uint256 amount, uint256 maxAmount, bytes calldata _signature) external payable{
require(allowlistActive, "not live");
require(totalSupply() + amount <= maxSupply , "sold out");
require(_verify(_signature, maxAmount, uint(alTypes.PAID)), "bad signature");
require(alClaims[msg.sender] + amount <= maxAmount, "max used");
if (maxAmount == 3){
require(allowlistMintPrice3 * amount == msg.value, "not enough eth");
} else {
require(<FILL_ME>)
}
alClaims[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function freeMint(uint256 amount, uint256 maxAmount, bytes calldata _signature) external{
}
function teamMint(uint256 amount, address _to) external onlyOwnerOrManager {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| allowlistMintPrice2*amount==msg.value,"not enough eth" | 398,925 | allowlistMintPrice2*amount==msg.value |
"bad signature" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract CandyHunters is
ERC721A,
Ownable
{
using ECDSA for bytes32;
enum alTypes {FREE, PAID}
mapping (address => uint256) public alClaims;
mapping (address => uint256) public freeClaims;
uint256 public constant teamSupply = 100;
uint256 public constant maxSupply = 10000;
uint256 public constant allowlistMintPrice2 = 0.05 ether;
uint256 public constant allowlistMintPrice3 = 0.04 ether;
uint256 public constant publicMintPrice = 0.06 ether;
uint256 public maxPerTx = 5;
uint256 public teamClaimCount = 0;
address public signerAddress = 0x7E4723A50108AC20CBE09cD9F656bd065f5B42c8;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address private _manager = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM1 = 0x45acf055d977D8EA41AF353D16D7ba83F9B79bd7;
address private TEAM2 = 0x723B5cB2b5F86660d5b8391d847DB40eeA34bf7c;
address private TEAM3 = 0x9a2197620d3268bA57bfb822Ebc0cEA7105cbA94;
address private TEAM4 = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM5 = 0x8cc1B927E8691F825D213E1f404BCCbF9AA08490;
address private TEAM6 = 0x0B5063760d05b151418d7D8B6947C5d81649c6C6;
address private COMMUNITY_FUND = 0x01402DAebB58062FDbD76A378789e3Fa5F009196;
address private SECONDARY_FUND = 0x08c239fCE14d628b891B8882ED60733F6aDF5B3A;
string public baseUri = "https://mint.candyhuntersnft.io/api/token/";
string public endingUri = ".json";
bool public allowlistActive = false;
bool public publicActive = false;
constructor () ERC721A("Candy Hunters", "CANDY") {
}
receive() external payable {}
modifier onlyOwnerOrManager() {
}
function _startTokenId() internal pure override(ERC721A) returns(uint256 startId) {
}
function flipPublicSaleState() public onlyOwnerOrManager {
}
function flipAllowlistSaleState() public onlyOwnerOrManager {
}
function setManager(address manager) external onlyOwnerOrManager {
}
function setProxyRegistry(address preg) external onlyOwnerOrManager {
}
function setSignerAddress(address signer) external onlyOwnerOrManager {
}
function setBaseURI(string memory _URI) external onlyOwnerOrManager {
}
function setEndingURI(string memory _URI) external onlyOwnerOrManager {
}
function withdrawBackup() external onlyOwnerOrManager {
}
function withdrawAll() external onlyOwnerOrManager {
}
function _withdraw(address _address, uint256 _amount) private {
}
function _hash(address _address, uint256 quantity, uint256 alType) internal view returns (bytes32) {
}
function _verify( bytes memory signature, uint256 quantity, uint256 alType) internal view returns (bool) {
}
function publicMint(uint256 amount) external payable {
}
function allowlistMint( uint256 amount, uint256 maxAmount, bytes calldata _signature) external payable{
}
function freeMint(uint256 amount, uint256 maxAmount, bytes calldata _signature) external{
require(allowlistActive, "not live");
require(totalSupply() + amount <= maxSupply , "sold out");
require(<FILL_ME>)
require(freeClaims[msg.sender] + amount <= maxAmount, "max used");
freeClaims[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function teamMint(uint256 amount, address _to) external onlyOwnerOrManager {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| _verify(_signature,maxAmount,uint(alTypes.FREE)),"bad signature" | 398,925 | _verify(_signature,maxAmount,uint(alTypes.FREE)) |
"max used" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract CandyHunters is
ERC721A,
Ownable
{
using ECDSA for bytes32;
enum alTypes {FREE, PAID}
mapping (address => uint256) public alClaims;
mapping (address => uint256) public freeClaims;
uint256 public constant teamSupply = 100;
uint256 public constant maxSupply = 10000;
uint256 public constant allowlistMintPrice2 = 0.05 ether;
uint256 public constant allowlistMintPrice3 = 0.04 ether;
uint256 public constant publicMintPrice = 0.06 ether;
uint256 public maxPerTx = 5;
uint256 public teamClaimCount = 0;
address public signerAddress = 0x7E4723A50108AC20CBE09cD9F656bd065f5B42c8;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address private _manager = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM1 = 0x45acf055d977D8EA41AF353D16D7ba83F9B79bd7;
address private TEAM2 = 0x723B5cB2b5F86660d5b8391d847DB40eeA34bf7c;
address private TEAM3 = 0x9a2197620d3268bA57bfb822Ebc0cEA7105cbA94;
address private TEAM4 = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM5 = 0x8cc1B927E8691F825D213E1f404BCCbF9AA08490;
address private TEAM6 = 0x0B5063760d05b151418d7D8B6947C5d81649c6C6;
address private COMMUNITY_FUND = 0x01402DAebB58062FDbD76A378789e3Fa5F009196;
address private SECONDARY_FUND = 0x08c239fCE14d628b891B8882ED60733F6aDF5B3A;
string public baseUri = "https://mint.candyhuntersnft.io/api/token/";
string public endingUri = ".json";
bool public allowlistActive = false;
bool public publicActive = false;
constructor () ERC721A("Candy Hunters", "CANDY") {
}
receive() external payable {}
modifier onlyOwnerOrManager() {
}
function _startTokenId() internal pure override(ERC721A) returns(uint256 startId) {
}
function flipPublicSaleState() public onlyOwnerOrManager {
}
function flipAllowlistSaleState() public onlyOwnerOrManager {
}
function setManager(address manager) external onlyOwnerOrManager {
}
function setProxyRegistry(address preg) external onlyOwnerOrManager {
}
function setSignerAddress(address signer) external onlyOwnerOrManager {
}
function setBaseURI(string memory _URI) external onlyOwnerOrManager {
}
function setEndingURI(string memory _URI) external onlyOwnerOrManager {
}
function withdrawBackup() external onlyOwnerOrManager {
}
function withdrawAll() external onlyOwnerOrManager {
}
function _withdraw(address _address, uint256 _amount) private {
}
function _hash(address _address, uint256 quantity, uint256 alType) internal view returns (bytes32) {
}
function _verify( bytes memory signature, uint256 quantity, uint256 alType) internal view returns (bool) {
}
function publicMint(uint256 amount) external payable {
}
function allowlistMint( uint256 amount, uint256 maxAmount, bytes calldata _signature) external payable{
}
function freeMint(uint256 amount, uint256 maxAmount, bytes calldata _signature) external{
require(allowlistActive, "not live");
require(totalSupply() + amount <= maxSupply , "sold out");
require(_verify(_signature, maxAmount, uint(alTypes.FREE)), "bad signature");
require(<FILL_ME>)
freeClaims[msg.sender] += amount;
_safeMint(msg.sender, amount);
}
function teamMint(uint256 amount, address _to) external onlyOwnerOrManager {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| freeClaims[msg.sender]+amount<=maxAmount,"max used" | 398,925 | freeClaims[msg.sender]+amount<=maxAmount |
"team supply sold out" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract OwnableDelegateProxy {}
contract ProxyRegistry {
mapping(address => OwnableDelegateProxy) public proxies;
}
contract CandyHunters is
ERC721A,
Ownable
{
using ECDSA for bytes32;
enum alTypes {FREE, PAID}
mapping (address => uint256) public alClaims;
mapping (address => uint256) public freeClaims;
uint256 public constant teamSupply = 100;
uint256 public constant maxSupply = 10000;
uint256 public constant allowlistMintPrice2 = 0.05 ether;
uint256 public constant allowlistMintPrice3 = 0.04 ether;
uint256 public constant publicMintPrice = 0.06 ether;
uint256 public maxPerTx = 5;
uint256 public teamClaimCount = 0;
address public signerAddress = 0x7E4723A50108AC20CBE09cD9F656bd065f5B42c8;
address public proxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1;
address private _manager = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM1 = 0x45acf055d977D8EA41AF353D16D7ba83F9B79bd7;
address private TEAM2 = 0x723B5cB2b5F86660d5b8391d847DB40eeA34bf7c;
address private TEAM3 = 0x9a2197620d3268bA57bfb822Ebc0cEA7105cbA94;
address private TEAM4 = 0xC7E97B7013Bd8574C7c76a25191D75E096dFf164;
address private TEAM5 = 0x8cc1B927E8691F825D213E1f404BCCbF9AA08490;
address private TEAM6 = 0x0B5063760d05b151418d7D8B6947C5d81649c6C6;
address private COMMUNITY_FUND = 0x01402DAebB58062FDbD76A378789e3Fa5F009196;
address private SECONDARY_FUND = 0x08c239fCE14d628b891B8882ED60733F6aDF5B3A;
string public baseUri = "https://mint.candyhuntersnft.io/api/token/";
string public endingUri = ".json";
bool public allowlistActive = false;
bool public publicActive = false;
constructor () ERC721A("Candy Hunters", "CANDY") {
}
receive() external payable {}
modifier onlyOwnerOrManager() {
}
function _startTokenId() internal pure override(ERC721A) returns(uint256 startId) {
}
function flipPublicSaleState() public onlyOwnerOrManager {
}
function flipAllowlistSaleState() public onlyOwnerOrManager {
}
function setManager(address manager) external onlyOwnerOrManager {
}
function setProxyRegistry(address preg) external onlyOwnerOrManager {
}
function setSignerAddress(address signer) external onlyOwnerOrManager {
}
function setBaseURI(string memory _URI) external onlyOwnerOrManager {
}
function setEndingURI(string memory _URI) external onlyOwnerOrManager {
}
function withdrawBackup() external onlyOwnerOrManager {
}
function withdrawAll() external onlyOwnerOrManager {
}
function _withdraw(address _address, uint256 _amount) private {
}
function _hash(address _address, uint256 quantity, uint256 alType) internal view returns (bytes32) {
}
function _verify( bytes memory signature, uint256 quantity, uint256 alType) internal view returns (bool) {
}
function publicMint(uint256 amount) external payable {
}
function allowlistMint( uint256 amount, uint256 maxAmount, bytes calldata _signature) external payable{
}
function freeMint(uint256 amount, uint256 maxAmount, bytes calldata _signature) external{
}
function teamMint(uint256 amount, address _to) external onlyOwnerOrManager {
require(totalSupply() + amount <= maxSupply , "sold out");
require(<FILL_ME>)
teamClaimCount += amount;
_safeMint(_to, amount);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
function isApprovedForAll(address owner, address operator)
override
public
view
returns (bool)
{
}
}
| teamClaimCount+amount<=teamSupply,"team supply sold out" | 398,925 | teamClaimCount+amount<=teamSupply |
"vault does not exist" | pragma solidity 0.7.3;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "./interface/IController.sol";
import "./interface/IStrategy.sol";
import "./interface/IVault.sol";
import "./Governable.sol";
contract Controller is IController, Governable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// [Grey list]
// An EOA can safely interact with the system no matter what.
// If you're using Metamask, you're using an EOA.
// Only smart contracts may be affected by this grey list.
//
// This contract will not be able to ban any EOA from the system
// even if an EOA is being added to the greyList, he/she will still be able
// to interact with the whole system as if nothing happened.
// Only smart contracts will be affected by being added to the greyList.
mapping (address => bool) public override greyList;
// All vaults that we have
mapping (address => bool) public vaults;
modifier validVault(address _vault){
require(<FILL_ME>)
_;
}
mapping (address => bool) public hardWorkers;
modifier onlyHardWorkerOrGovernance() {
}
constructor(address _storage)
Governable(_storage) public {
}
function addHardWorker(address _worker) public onlyGovernance {
}
function removeHardWorker(address _worker) public onlyGovernance {
}
function hasVault(address _vault) external override returns (bool) {
}
// Only smart contracts will be affected by the greyList.
function addToGreyList(address _target) public onlyGovernance {
}
function removeFromGreyList(address _target) public onlyGovernance {
}
function addVaultAndStrategy(address _vault, address _strategy) external override onlyGovernance {
}
function stakeOnsenFarm(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeSushiBar(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeXSushiFarm(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeOnx(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
// transfers token in the controller contract to the governance
function salvage(address _token, uint256 _amount) external override onlyGovernance {
}
function salvageStrategy(address _strategy, address _token, uint256 _amount) external override onlyGovernance {
}
}
| vaults[_vault],"vault does not exist" | 398,968 | vaults[_vault] |
"only hard worker can call this" | pragma solidity 0.7.3;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "./interface/IController.sol";
import "./interface/IStrategy.sol";
import "./interface/IVault.sol";
import "./Governable.sol";
contract Controller is IController, Governable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// [Grey list]
// An EOA can safely interact with the system no matter what.
// If you're using Metamask, you're using an EOA.
// Only smart contracts may be affected by this grey list.
//
// This contract will not be able to ban any EOA from the system
// even if an EOA is being added to the greyList, he/she will still be able
// to interact with the whole system as if nothing happened.
// Only smart contracts will be affected by being added to the greyList.
mapping (address => bool) public override greyList;
// All vaults that we have
mapping (address => bool) public vaults;
modifier validVault(address _vault){
}
mapping (address => bool) public hardWorkers;
modifier onlyHardWorkerOrGovernance() {
require(<FILL_ME>)
_;
}
constructor(address _storage)
Governable(_storage) public {
}
function addHardWorker(address _worker) public onlyGovernance {
}
function removeHardWorker(address _worker) public onlyGovernance {
}
function hasVault(address _vault) external override returns (bool) {
}
// Only smart contracts will be affected by the greyList.
function addToGreyList(address _target) public onlyGovernance {
}
function removeFromGreyList(address _target) public onlyGovernance {
}
function addVaultAndStrategy(address _vault, address _strategy) external override onlyGovernance {
}
function stakeOnsenFarm(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeSushiBar(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeXSushiFarm(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeOnx(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
// transfers token in the controller contract to the governance
function salvage(address _token, uint256 _amount) external override onlyGovernance {
}
function salvageStrategy(address _strategy, address _token, uint256 _amount) external override onlyGovernance {
}
}
| hardWorkers[msg.sender]||(msg.sender==governance()),"only hard worker can call this" | 398,968 | hardWorkers[msg.sender]||(msg.sender==governance()) |
"vault already exists" | pragma solidity 0.7.3;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "./interface/IController.sol";
import "./interface/IStrategy.sol";
import "./interface/IVault.sol";
import "./Governable.sol";
contract Controller is IController, Governable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
// [Grey list]
// An EOA can safely interact with the system no matter what.
// If you're using Metamask, you're using an EOA.
// Only smart contracts may be affected by this grey list.
//
// This contract will not be able to ban any EOA from the system
// even if an EOA is being added to the greyList, he/she will still be able
// to interact with the whole system as if nothing happened.
// Only smart contracts will be affected by being added to the greyList.
mapping (address => bool) public override greyList;
// All vaults that we have
mapping (address => bool) public vaults;
modifier validVault(address _vault){
}
mapping (address => bool) public hardWorkers;
modifier onlyHardWorkerOrGovernance() {
}
constructor(address _storage)
Governable(_storage) public {
}
function addHardWorker(address _worker) public onlyGovernance {
}
function removeHardWorker(address _worker) public onlyGovernance {
}
function hasVault(address _vault) external override returns (bool) {
}
// Only smart contracts will be affected by the greyList.
function addToGreyList(address _target) public onlyGovernance {
}
function removeFromGreyList(address _target) public onlyGovernance {
}
function addVaultAndStrategy(address _vault, address _strategy) external override onlyGovernance {
require(_vault != address(0), "new vault shouldn't be empty");
require(<FILL_ME>)
require(_strategy != address(0), "new strategy shouldn't be empty");
vaults[_vault] = true;
// adding happens while setting
IVault(_vault).setStrategy(_strategy);
}
function stakeOnsenFarm(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeSushiBar(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeXSushiFarm(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
function stakeOnx(address _vault) external override onlyHardWorkerOrGovernance validVault(_vault) {
}
// transfers token in the controller contract to the governance
function salvage(address _token, uint256 _amount) external override onlyGovernance {
}
function salvageStrategy(address _strategy, address _token, uint256 _amount) external override onlyGovernance {
}
}
| !vaults[_vault],"vault already exists" | 398,968 | !vaults[_vault] |
null | pragma solidity ^0.4.18;
contract FullERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 public totalSupply;
uint8 public decimals;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 RewardDistributable {
event TokensRewarded(address indexed player, address rewardToken, uint rewards, address requester, uint gameId, uint block);
event ReferralRewarded(address indexed referrer, address indexed player, address rewardToken, uint rewards, uint gameId, uint block);
event ReferralRegistered(address indexed player, address indexed referrer);
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public;
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant returns(uint);
/// @dev Returns the total number of supported reward token contracts.
function getRewardTokenCount() public constant returns(uint);
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint);
/// @dev Gets the reward rate inclusive of referral bonus.
function getRewardRate(address player, address tokenAddress) public constant returns(uint);
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public;
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public;
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public;
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public;
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function removeRewardToken(address tokenAddress) public;
/// @dev Updates the referral bonus rate
function updateReferralBonusRate(uint newReferralBonusRate) public;
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public;
/// @dev Transfers any tokens to the owner
function destroyRewards() public;
}
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) {
}
}
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 {
}
}
contract RewardDistributor is RewardDistributable, Ownable {
using SafeMath for uint256;
struct RewardSource {
address rewardTokenAddress;
uint96 rewardRate; // 1 token for every reward rate (in wei)
}
RewardSource[] public rewardSources;
mapping(address => bool) public approvedRewardSources;
mapping(address => bool) public requesters; // distribution requesters
address[] public approvers; // distribution approvers
mapping(address => address) public referrers; // player -> referrer
uint public referralBonusRate;
modifier onlyRequesters() {
require(<FILL_ME>)
_;
}
modifier validRewardSource(address tokenAddress) {
}
function RewardDistributor(uint256 rewardRate, address tokenAddress) public {
}
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public onlyRequesters {
}
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Get reward token count
function getRewardTokenCount() public constant returns(uint) {
}
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint) {
}
/// @dev Gets the reward rate inclusive of bonus.
/// This is meant to be used by dividing the total purchase amount in wei by this amount.
function getRewardRate(address player, address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public onlyOwner {
}
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public onlyOwner {
}
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public onlyOwner {
}
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public onlyOwner {
}
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Adds the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Removes the given token address from the approved sources.
/// @param tokenAddress the address of the token
function removeRewardToken(address tokenAddress) public onlyOwner {
}
/// @dev Transfers any tokens to the owner
function destroyRewards() public onlyOwner {
}
/// @dev Updates the referral bonus percentage
function updateReferralBonusRate(uint newReferralBonusRate) public onlyOwner {
}
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public onlyRequesters {
}
/// @dev Transfers the rewards to the player for the provided reward source
function transferRewardsInternal(address player, uint entryAmount, uint gameId, RewardSource storage rewardSource) internal {
}
}
| requesters[msg.sender]||(msg.sender==owner) | 399,014 | requesters[msg.sender]||(msg.sender==owner) |
null | pragma solidity ^0.4.18;
contract FullERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 public totalSupply;
uint8 public decimals;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 RewardDistributable {
event TokensRewarded(address indexed player, address rewardToken, uint rewards, address requester, uint gameId, uint block);
event ReferralRewarded(address indexed referrer, address indexed player, address rewardToken, uint rewards, uint gameId, uint block);
event ReferralRegistered(address indexed player, address indexed referrer);
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public;
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant returns(uint);
/// @dev Returns the total number of supported reward token contracts.
function getRewardTokenCount() public constant returns(uint);
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint);
/// @dev Gets the reward rate inclusive of referral bonus.
function getRewardRate(address player, address tokenAddress) public constant returns(uint);
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public;
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public;
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public;
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public;
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function removeRewardToken(address tokenAddress) public;
/// @dev Updates the referral bonus rate
function updateReferralBonusRate(uint newReferralBonusRate) public;
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public;
/// @dev Transfers any tokens to the owner
function destroyRewards() public;
}
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) {
}
}
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 {
}
}
contract RewardDistributor is RewardDistributable, Ownable {
using SafeMath for uint256;
struct RewardSource {
address rewardTokenAddress;
uint96 rewardRate; // 1 token for every reward rate (in wei)
}
RewardSource[] public rewardSources;
mapping(address => bool) public approvedRewardSources;
mapping(address => bool) public requesters; // distribution requesters
address[] public approvers; // distribution approvers
mapping(address => address) public referrers; // player -> referrer
uint public referralBonusRate;
modifier onlyRequesters() {
}
modifier validRewardSource(address tokenAddress) {
require(<FILL_ME>)
_;
}
function RewardDistributor(uint256 rewardRate, address tokenAddress) public {
}
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public onlyRequesters {
}
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Get reward token count
function getRewardTokenCount() public constant returns(uint) {
}
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint) {
}
/// @dev Gets the reward rate inclusive of bonus.
/// This is meant to be used by dividing the total purchase amount in wei by this amount.
function getRewardRate(address player, address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public onlyOwner {
}
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public onlyOwner {
}
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public onlyOwner {
}
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public onlyOwner {
}
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Adds the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Removes the given token address from the approved sources.
/// @param tokenAddress the address of the token
function removeRewardToken(address tokenAddress) public onlyOwner {
}
/// @dev Transfers any tokens to the owner
function destroyRewards() public onlyOwner {
}
/// @dev Updates the referral bonus percentage
function updateReferralBonusRate(uint newReferralBonusRate) public onlyOwner {
}
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public onlyRequesters {
}
/// @dev Transfers the rewards to the player for the provided reward source
function transferRewardsInternal(address player, uint entryAmount, uint gameId, RewardSource storage rewardSource) internal {
}
}
| approvedRewardSources[tokenAddress] | 399,014 | approvedRewardSources[tokenAddress] |
null | pragma solidity ^0.4.18;
contract FullERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 public totalSupply;
uint8 public decimals;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 RewardDistributable {
event TokensRewarded(address indexed player, address rewardToken, uint rewards, address requester, uint gameId, uint block);
event ReferralRewarded(address indexed referrer, address indexed player, address rewardToken, uint rewards, uint gameId, uint block);
event ReferralRegistered(address indexed player, address indexed referrer);
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public;
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant returns(uint);
/// @dev Returns the total number of supported reward token contracts.
function getRewardTokenCount() public constant returns(uint);
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint);
/// @dev Gets the reward rate inclusive of referral bonus.
function getRewardRate(address player, address tokenAddress) public constant returns(uint);
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public;
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public;
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public;
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public;
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function removeRewardToken(address tokenAddress) public;
/// @dev Updates the referral bonus rate
function updateReferralBonusRate(uint newReferralBonusRate) public;
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public;
/// @dev Transfers any tokens to the owner
function destroyRewards() public;
}
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) {
}
}
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 {
}
}
contract RewardDistributor is RewardDistributable, Ownable {
using SafeMath for uint256;
struct RewardSource {
address rewardTokenAddress;
uint96 rewardRate; // 1 token for every reward rate (in wei)
}
RewardSource[] public rewardSources;
mapping(address => bool) public approvedRewardSources;
mapping(address => bool) public requesters; // distribution requesters
address[] public approvers; // distribution approvers
mapping(address => address) public referrers; // player -> referrer
uint public referralBonusRate;
modifier onlyRequesters() {
}
modifier validRewardSource(address tokenAddress) {
}
function RewardDistributor(uint256 rewardRate, address tokenAddress) public {
}
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public onlyRequesters {
}
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Get reward token count
function getRewardTokenCount() public constant returns(uint) {
}
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint) {
}
/// @dev Gets the reward rate inclusive of bonus.
/// This is meant to be used by dividing the total purchase amount in wei by this amount.
function getRewardRate(address player, address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public onlyOwner {
require(<FILL_ME>)
requesters[requester] = true;
}
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public onlyOwner {
}
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public onlyOwner {
}
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public onlyOwner {
}
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Adds the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Removes the given token address from the approved sources.
/// @param tokenAddress the address of the token
function removeRewardToken(address tokenAddress) public onlyOwner {
}
/// @dev Transfers any tokens to the owner
function destroyRewards() public onlyOwner {
}
/// @dev Updates the referral bonus percentage
function updateReferralBonusRate(uint newReferralBonusRate) public onlyOwner {
}
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public onlyRequesters {
}
/// @dev Transfers the rewards to the player for the provided reward source
function transferRewardsInternal(address player, uint entryAmount, uint gameId, RewardSource storage rewardSource) internal {
}
}
| !requesters[requester] | 399,014 | !requesters[requester] |
null | pragma solidity ^0.4.18;
contract FullERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 public totalSupply;
uint8 public decimals;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 RewardDistributable {
event TokensRewarded(address indexed player, address rewardToken, uint rewards, address requester, uint gameId, uint block);
event ReferralRewarded(address indexed referrer, address indexed player, address rewardToken, uint rewards, uint gameId, uint block);
event ReferralRegistered(address indexed player, address indexed referrer);
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public;
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant returns(uint);
/// @dev Returns the total number of supported reward token contracts.
function getRewardTokenCount() public constant returns(uint);
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint);
/// @dev Gets the reward rate inclusive of referral bonus.
function getRewardRate(address player, address tokenAddress) public constant returns(uint);
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public;
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public;
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public;
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public;
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function removeRewardToken(address tokenAddress) public;
/// @dev Updates the referral bonus rate
function updateReferralBonusRate(uint newReferralBonusRate) public;
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public;
/// @dev Transfers any tokens to the owner
function destroyRewards() public;
}
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) {
}
}
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 {
}
}
contract RewardDistributor is RewardDistributable, Ownable {
using SafeMath for uint256;
struct RewardSource {
address rewardTokenAddress;
uint96 rewardRate; // 1 token for every reward rate (in wei)
}
RewardSource[] public rewardSources;
mapping(address => bool) public approvedRewardSources;
mapping(address => bool) public requesters; // distribution requesters
address[] public approvers; // distribution approvers
mapping(address => address) public referrers; // player -> referrer
uint public referralBonusRate;
modifier onlyRequesters() {
}
modifier validRewardSource(address tokenAddress) {
}
function RewardDistributor(uint256 rewardRate, address tokenAddress) public {
}
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public onlyRequesters {
}
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Get reward token count
function getRewardTokenCount() public constant returns(uint) {
}
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint) {
}
/// @dev Gets the reward rate inclusive of bonus.
/// This is meant to be used by dividing the total purchase amount in wei by this amount.
function getRewardRate(address player, address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public onlyOwner {
}
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public onlyOwner {
require(<FILL_ME>)
requesters[requester] = false;
}
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public onlyOwner {
}
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public onlyOwner {
}
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Adds the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Removes the given token address from the approved sources.
/// @param tokenAddress the address of the token
function removeRewardToken(address tokenAddress) public onlyOwner {
}
/// @dev Transfers any tokens to the owner
function destroyRewards() public onlyOwner {
}
/// @dev Updates the referral bonus percentage
function updateReferralBonusRate(uint newReferralBonusRate) public onlyOwner {
}
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public onlyRequesters {
}
/// @dev Transfers the rewards to the player for the provided reward source
function transferRewardsInternal(address player, uint entryAmount, uint gameId, RewardSource storage rewardSource) internal {
}
}
| requesters[requester] | 399,014 | requesters[requester] |
null | pragma solidity ^0.4.18;
contract FullERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 public totalSupply;
uint8 public decimals;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
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 RewardDistributable {
event TokensRewarded(address indexed player, address rewardToken, uint rewards, address requester, uint gameId, uint block);
event ReferralRewarded(address indexed referrer, address indexed player, address rewardToken, uint rewards, uint gameId, uint block);
event ReferralRegistered(address indexed player, address indexed referrer);
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public;
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant returns(uint);
/// @dev Returns the total number of supported reward token contracts.
function getRewardTokenCount() public constant returns(uint);
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint);
/// @dev Gets the reward rate inclusive of referral bonus.
function getRewardRate(address player, address tokenAddress) public constant returns(uint);
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public;
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public;
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public;
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public;
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public;
/// @dev Updates the token address of the payment type.
function removeRewardToken(address tokenAddress) public;
/// @dev Updates the referral bonus rate
function updateReferralBonusRate(uint newReferralBonusRate) public;
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public;
/// @dev Transfers any tokens to the owner
function destroyRewards() public;
}
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) {
}
}
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 {
}
}
contract RewardDistributor is RewardDistributable, Ownable {
using SafeMath for uint256;
struct RewardSource {
address rewardTokenAddress;
uint96 rewardRate; // 1 token for every reward rate (in wei)
}
RewardSource[] public rewardSources;
mapping(address => bool) public approvedRewardSources;
mapping(address => bool) public requesters; // distribution requesters
address[] public approvers; // distribution approvers
mapping(address => address) public referrers; // player -> referrer
uint public referralBonusRate;
modifier onlyRequesters() {
}
modifier validRewardSource(address tokenAddress) {
}
function RewardDistributor(uint256 rewardRate, address tokenAddress) public {
}
/// @dev Calculates and transfers the rewards to the player.
function transferRewards(address player, uint entryAmount, uint gameId) public onlyRequesters {
}
/// @dev Returns the total number of tokens, across all approvals.
function getTotalTokens(address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Get reward token count
function getRewardTokenCount() public constant returns(uint) {
}
/// @dev Gets the total number of approvers.
function getTotalApprovers() public constant returns(uint) {
}
/// @dev Gets the reward rate inclusive of bonus.
/// This is meant to be used by dividing the total purchase amount in wei by this amount.
function getRewardRate(address player, address tokenAddress) public constant validRewardSource(tokenAddress) returns(uint) {
}
/// @dev Adds a requester to the whitelist.
/// @param requester The address of a contract which will request reward transfers
function addRequester(address requester) public onlyOwner {
}
/// @dev Removes a requester from the whitelist.
/// @param requester The address of a contract which will request reward transfers
function removeRequester(address requester) public onlyOwner {
}
/// @dev Adds a approver address. Approval happens with the token contract.
/// @param approver The approver address to add to the pool.
function addApprover(address approver) public onlyOwner {
}
/// @dev Removes an approver address.
/// @param approver The approver address to remove from the pool.
function removeApprover(address approver) public onlyOwner {
}
/// @dev Updates the reward rate
function updateRewardRate(address tokenAddress, uint newRewardRate) public onlyOwner {
}
/// @dev Adds the token address of the payment type.
function addRewardToken(address tokenAddress, uint newRewardRate) public onlyOwner {
require(tokenAddress != address(0));
require(<FILL_ME>)
rewardSources.push(RewardSource(tokenAddress, uint96(newRewardRate)));
approvedRewardSources[tokenAddress] = true;
}
/// @dev Removes the given token address from the approved sources.
/// @param tokenAddress the address of the token
function removeRewardToken(address tokenAddress) public onlyOwner {
}
/// @dev Transfers any tokens to the owner
function destroyRewards() public onlyOwner {
}
/// @dev Updates the referral bonus percentage
function updateReferralBonusRate(uint newReferralBonusRate) public onlyOwner {
}
/// @dev Registers the player with the given referral code
/// @param player The address of the player
/// @param referrer The address of the referrer
function registerReferral(address player, address referrer) public onlyRequesters {
}
/// @dev Transfers the rewards to the player for the provided reward source
function transferRewardsInternal(address player, uint entryAmount, uint gameId, RewardSource storage rewardSource) internal {
}
}
| !approvedRewardSources[tokenAddress] | 399,014 | !approvedRewardSources[tokenAddress] |
"may not be contract address" | pragma solidity 0.6.4;
import "./SafeMath.sol";
import "./IERC20.sol";
import "./Address.sol";
//
//██╗░░██╗░█████╗░██████╗░██╗░░░░░░░░██████╗░░█████╗░░██████╗░
//██║░░██║██╔══██╗██╔══██╗██║░░░░░░░░██╔══██╗██╔══██╗██╔════╝░
//███████║██║░░██║██║░░██║██║░░░░░░░░██████╦╝███████║██║░░██╗░
//██╔══██║██║░░██║██║░░██║██║░░░░░░░░██╔══██╗██╔══██║██║░░╚██╗
//██║░░██║╚█████╔╝██████╔╝███████╗██╗██████╦╝██║░░██║╚██████╔╝
//╚═╝░░╚═╝░╚════╝░╚═════╝░╚══════╝╚═╝╚═════╝░╚═╝░░╚═╝░╚═════╝░
//───────────────▄▄───▐█
//───▄▄▄───▄██▄──█▀───█─▄
//─▄██▀█▌─██▄▄──▐█▀▄─▐█▀
//▐█▀▀▌───▄▀▌─▌─█─▌──▌─▌
//▌▀▄─▐──▀▄─▐▄─▐▄▐▄─▐▄─▐▄
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
}
}
//
//█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀█
//█░░╦─╦╔╗╦─╔╗╔╗╔╦╗╔╗░░█
//█░░║║║╠─║─║─║║║║║╠─░░█
//█░░╚╩╝╚╝╚╝╚╝╚╝╩─╩╚╝░░█
//█▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄█
//
contract HODLBAG is IERC20 {
using SafeMath for uint256;
using SafeMath for uint8;
using SafeERC20 for HODLBAG;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
//tokenomics
uint256 internal _totalSupply;
string public constant name = "hodl.bag";
string public constant symbol = "HODLBAG";
uint8 public constant decimals = 8;
bool private sync;
address private admin1 = address(0xbEb90b87629892A9FE9D47dF81b2F87ab7A9BA8F);
mapping(address => bool) admins;
modifier onlyAdmins(){
}
//protects against potential reentrancy
modifier synchronized {
}
constructor(uint256 initialTokens) public {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal {
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply unless mintBLock is true
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements
*
* - `to` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal {
}
/**
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
* from the caller's allowance.
*
* See {_burn} and {_approve}.
*/
function _burnFrom(address account, uint256 amount) internal {
}
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);//from address(0) for minting
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
//donate any eth sent to contract
receive() external payable{
}
//mint HODLBAG supply
function mintSupply(uint amount)
internal
onlyAdmins
synchronized
{
}
//acquire any random tokens dropped to contract
function tokenDrop(address tokenAddress)
public
onlyAdmins
{
require(tokenAddress != address(this));
require(<FILL_ME>)
uint tokenBal = IERC20(tokenAddress).balanceOf(address(this));
IERC20(tokenAddress).transfer(admin1, tokenBal);
}
function donate()
public
payable
{
}
}
//
//╔══╗░░░░╔╦╗░░╔═════╗
//║╚═╬════╬╣╠═╗║░▀░▀░║
//╠═╗║╔╗╔╗║║║╩╣║╚═══╝║
//╚══╩╝╚╝╚╩╩╩═╝╚═════╝
//
| IERC20(tokenAddress).totalSupply()>0,"may not be contract address" | 399,055 | IERC20(tokenAddress).totalSupply()>0 |
"This cannot be modified after the presale is done" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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 _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library Constants {
uint256 private constant MAX = ~uint256(0);
uint256 private constant _launchSupply = 100000 * 10**9;
uint256 private constant _largeTotal = (MAX - (MAX % _launchSupply));
uint256 private constant _baseExpansionFactor = 100;
uint256 private constant _baseContractionFactor = 100;
uint256 private constant _baseUtilityFee = 50;
uint256 private constant _baseContractionCap = 1000;
uint256 private constant _stabilizerFee = 250;
uint256 private constant _stabilizationLowerBound = 50;
uint256 private constant _stabilizationLowerReset = 75;
uint256 private constant _stabilizationUpperBound = 150;
uint256 private constant _stabilizationUpperReset = 125;
uint256 private constant _stabilizePercent = 10;
uint256 private constant _treasuryFee = 250;
uint256 private constant _presaleMinIndividualCap = 1 ether;
uint256 private constant _presaleMaxIndividualCap = 3 ether;
uint256 private constant _presaleCap = 55000 * 10**9;
uint256 private constant _maxPresaleGas = 200000000000;
uint256 private constant _epochLength = 30 minutes;
uint256 private constant _liquidityReward = 5 * 10**9;
uint256 private constant _minForLiquidity = 20 * 10**9;
uint256 private constant _minForCallerLiquidity = 20 * 10**9;
address private constant _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private constant _factoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address payable private constant _deployerAddress = 0xA5C30116b6E926Ec0F159649c724eE6058F4953D;
address private constant _treasuryAddress = 0xA5C30116b6E926Ec0F159649c724eE6058F4953D;
uint256 private constant _presaleRate = 27500;
uint256 private constant _listingRate = 23333;
string private constant _name = "SpeedXStable";
string private constant _symbol = "SXST";
uint8 private constant _decimals = 9;
/****** Getters *******/
function getPresaleRate() internal pure returns (uint256) {
}
function getListingRate() internal pure returns (uint256) {
}
function getLaunchSupply() internal pure returns (uint256) {
}
function getLargeTotal() internal pure returns (uint256) {
}
function getPresaleCap() internal pure returns (uint256) {
}
function getPresaleMinIndividualCap() internal pure returns (uint256) {
}
function getPresaleMaxIndividualCap() internal pure returns (uint256) {
}
function getMaxPresaleGas() internal pure returns (uint256) {
}
function getBaseExpansionFactor() internal pure returns (uint256) {
}
function getBaseContractionFactor() internal pure returns (uint256) {
}
function getBaseContractionCap() internal pure returns (uint256) {
}
function getBaseUtilityFee() internal pure returns (uint256) {
}
function getStabilizerFee() internal pure returns (uint256) {
}
function getStabilizationLowerBound() internal pure returns (uint256) {
}
function getStabilizationLowerReset() internal pure returns (uint256) {
}
function getStabilizationUpperBound() internal pure returns (uint256) {
}
function getStabilizationUpperReset() internal pure returns (uint256) {
}
function getStabilizePercent() internal pure returns (uint256) {
}
function getTreasuryFee() internal pure returns (uint256) {
}
function getEpochLength() internal pure returns (uint256) {
}
function getLiquidityReward() internal pure returns (uint256) {
}
function getMinForLiquidity() internal pure returns (uint256) {
}
function getMinForCallerLiquidity() internal pure returns (uint256) {
}
function getRouterAdd() internal pure returns (address) {
}
function getFactoryAdd() internal pure returns (address) {
}
function getDeployerAdd() internal pure returns (address payable) {
}
function getTreasuryAdd() internal pure returns (address) {
}
function getName() internal pure returns (string memory) {
}
function getSymbol() internal pure returns (string memory) {
}
function getDecimals() internal pure returns (uint8) {
}
}
interface IXStable {
function isPresaleDone() external view returns (bool);
function mint(address to, uint256 amount) external;
function setPresaleDone() external payable;
}
contract Presale is Context, Ownable {
using SafeMath for uint256;
using Address for address;
IXStable token;
// Presale stuff below
uint256 private _presaleMint;
uint256 public presaleTime = now;
uint256 public presalePrice;
mapping (address => uint256) private _presaleParticipation;
bool public presale = false;
constructor (address tokenAdd) public {
}
function setPresaleTime(uint256 time) external onlyOwner() {
require(<FILL_ME>)
presaleTime = time;
}
function setPresaleFlag(bool flag) external onlyOwner() {
}
function setPresalePrice(uint256 priceInWei) external onlyOwner() {
}
// Presale function
receive() external payable {
}
function presaleDone() external onlyOwner() {
}
function emergencyWithdraw() external onlyOwner() {
}
}
| token.isPresaleDone()==false,"This cannot be modified after the presale is done" | 399,105 | token.isPresaleDone()==false |
"This cannot be modified after the presale is done" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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 _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library Constants {
uint256 private constant MAX = ~uint256(0);
uint256 private constant _launchSupply = 100000 * 10**9;
uint256 private constant _largeTotal = (MAX - (MAX % _launchSupply));
uint256 private constant _baseExpansionFactor = 100;
uint256 private constant _baseContractionFactor = 100;
uint256 private constant _baseUtilityFee = 50;
uint256 private constant _baseContractionCap = 1000;
uint256 private constant _stabilizerFee = 250;
uint256 private constant _stabilizationLowerBound = 50;
uint256 private constant _stabilizationLowerReset = 75;
uint256 private constant _stabilizationUpperBound = 150;
uint256 private constant _stabilizationUpperReset = 125;
uint256 private constant _stabilizePercent = 10;
uint256 private constant _treasuryFee = 250;
uint256 private constant _presaleMinIndividualCap = 1 ether;
uint256 private constant _presaleMaxIndividualCap = 3 ether;
uint256 private constant _presaleCap = 55000 * 10**9;
uint256 private constant _maxPresaleGas = 200000000000;
uint256 private constant _epochLength = 30 minutes;
uint256 private constant _liquidityReward = 5 * 10**9;
uint256 private constant _minForLiquidity = 20 * 10**9;
uint256 private constant _minForCallerLiquidity = 20 * 10**9;
address private constant _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private constant _factoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address payable private constant _deployerAddress = 0xA5C30116b6E926Ec0F159649c724eE6058F4953D;
address private constant _treasuryAddress = 0xA5C30116b6E926Ec0F159649c724eE6058F4953D;
uint256 private constant _presaleRate = 27500;
uint256 private constant _listingRate = 23333;
string private constant _name = "SpeedXStable";
string private constant _symbol = "SXST";
uint8 private constant _decimals = 9;
/****** Getters *******/
function getPresaleRate() internal pure returns (uint256) {
}
function getListingRate() internal pure returns (uint256) {
}
function getLaunchSupply() internal pure returns (uint256) {
}
function getLargeTotal() internal pure returns (uint256) {
}
function getPresaleCap() internal pure returns (uint256) {
}
function getPresaleMinIndividualCap() internal pure returns (uint256) {
}
function getPresaleMaxIndividualCap() internal pure returns (uint256) {
}
function getMaxPresaleGas() internal pure returns (uint256) {
}
function getBaseExpansionFactor() internal pure returns (uint256) {
}
function getBaseContractionFactor() internal pure returns (uint256) {
}
function getBaseContractionCap() internal pure returns (uint256) {
}
function getBaseUtilityFee() internal pure returns (uint256) {
}
function getStabilizerFee() internal pure returns (uint256) {
}
function getStabilizationLowerBound() internal pure returns (uint256) {
}
function getStabilizationLowerReset() internal pure returns (uint256) {
}
function getStabilizationUpperBound() internal pure returns (uint256) {
}
function getStabilizationUpperReset() internal pure returns (uint256) {
}
function getStabilizePercent() internal pure returns (uint256) {
}
function getTreasuryFee() internal pure returns (uint256) {
}
function getEpochLength() internal pure returns (uint256) {
}
function getLiquidityReward() internal pure returns (uint256) {
}
function getMinForLiquidity() internal pure returns (uint256) {
}
function getMinForCallerLiquidity() internal pure returns (uint256) {
}
function getRouterAdd() internal pure returns (address) {
}
function getFactoryAdd() internal pure returns (address) {
}
function getDeployerAdd() internal pure returns (address payable) {
}
function getTreasuryAdd() internal pure returns (address) {
}
function getName() internal pure returns (string memory) {
}
function getSymbol() internal pure returns (string memory) {
}
function getDecimals() internal pure returns (uint8) {
}
}
interface IXStable {
function isPresaleDone() external view returns (bool);
function mint(address to, uint256 amount) external;
function setPresaleDone() external payable;
}
contract Presale is Context, Ownable {
using SafeMath for uint256;
using Address for address;
IXStable token;
// Presale stuff below
uint256 private _presaleMint;
uint256 public presaleTime = now;
uint256 public presalePrice;
mapping (address => uint256) private _presaleParticipation;
bool public presale = false;
constructor (address tokenAdd) public {
}
function setPresaleTime(uint256 time) external onlyOwner() {
}
function setPresaleFlag(bool flag) external onlyOwner() {
require(<FILL_ME>)
if (flag == true) {
require(presalePrice > 0, "Sale price has to be greater than 0");
}
presale = flag;
}
function setPresalePrice(uint256 priceInWei) external onlyOwner() {
}
// Presale function
receive() external payable {
}
function presaleDone() external onlyOwner() {
}
function emergencyWithdraw() external onlyOwner() {
}
}
| !token.isPresaleDone(),"This cannot be modified after the presale is done" | 399,105 | !token.isPresaleDone() |
"Can only be set before presale starts" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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 _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library Constants {
uint256 private constant MAX = ~uint256(0);
uint256 private constant _launchSupply = 100000 * 10**9;
uint256 private constant _largeTotal = (MAX - (MAX % _launchSupply));
uint256 private constant _baseExpansionFactor = 100;
uint256 private constant _baseContractionFactor = 100;
uint256 private constant _baseUtilityFee = 50;
uint256 private constant _baseContractionCap = 1000;
uint256 private constant _stabilizerFee = 250;
uint256 private constant _stabilizationLowerBound = 50;
uint256 private constant _stabilizationLowerReset = 75;
uint256 private constant _stabilizationUpperBound = 150;
uint256 private constant _stabilizationUpperReset = 125;
uint256 private constant _stabilizePercent = 10;
uint256 private constant _treasuryFee = 250;
uint256 private constant _presaleMinIndividualCap = 1 ether;
uint256 private constant _presaleMaxIndividualCap = 3 ether;
uint256 private constant _presaleCap = 55000 * 10**9;
uint256 private constant _maxPresaleGas = 200000000000;
uint256 private constant _epochLength = 30 minutes;
uint256 private constant _liquidityReward = 5 * 10**9;
uint256 private constant _minForLiquidity = 20 * 10**9;
uint256 private constant _minForCallerLiquidity = 20 * 10**9;
address private constant _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private constant _factoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address payable private constant _deployerAddress = 0xA5C30116b6E926Ec0F159649c724eE6058F4953D;
address private constant _treasuryAddress = 0xA5C30116b6E926Ec0F159649c724eE6058F4953D;
uint256 private constant _presaleRate = 27500;
uint256 private constant _listingRate = 23333;
string private constant _name = "SpeedXStable";
string private constant _symbol = "SXST";
uint8 private constant _decimals = 9;
/****** Getters *******/
function getPresaleRate() internal pure returns (uint256) {
}
function getListingRate() internal pure returns (uint256) {
}
function getLaunchSupply() internal pure returns (uint256) {
}
function getLargeTotal() internal pure returns (uint256) {
}
function getPresaleCap() internal pure returns (uint256) {
}
function getPresaleMinIndividualCap() internal pure returns (uint256) {
}
function getPresaleMaxIndividualCap() internal pure returns (uint256) {
}
function getMaxPresaleGas() internal pure returns (uint256) {
}
function getBaseExpansionFactor() internal pure returns (uint256) {
}
function getBaseContractionFactor() internal pure returns (uint256) {
}
function getBaseContractionCap() internal pure returns (uint256) {
}
function getBaseUtilityFee() internal pure returns (uint256) {
}
function getStabilizerFee() internal pure returns (uint256) {
}
function getStabilizationLowerBound() internal pure returns (uint256) {
}
function getStabilizationLowerReset() internal pure returns (uint256) {
}
function getStabilizationUpperBound() internal pure returns (uint256) {
}
function getStabilizationUpperReset() internal pure returns (uint256) {
}
function getStabilizePercent() internal pure returns (uint256) {
}
function getTreasuryFee() internal pure returns (uint256) {
}
function getEpochLength() internal pure returns (uint256) {
}
function getLiquidityReward() internal pure returns (uint256) {
}
function getMinForLiquidity() internal pure returns (uint256) {
}
function getMinForCallerLiquidity() internal pure returns (uint256) {
}
function getRouterAdd() internal pure returns (address) {
}
function getFactoryAdd() internal pure returns (address) {
}
function getDeployerAdd() internal pure returns (address payable) {
}
function getTreasuryAdd() internal pure returns (address) {
}
function getName() internal pure returns (string memory) {
}
function getSymbol() internal pure returns (string memory) {
}
function getDecimals() internal pure returns (uint8) {
}
}
interface IXStable {
function isPresaleDone() external view returns (bool);
function mint(address to, uint256 amount) external;
function setPresaleDone() external payable;
}
contract Presale is Context, Ownable {
using SafeMath for uint256;
using Address for address;
IXStable token;
// Presale stuff below
uint256 private _presaleMint;
uint256 public presaleTime = now;
uint256 public presalePrice;
mapping (address => uint256) private _presaleParticipation;
bool public presale = false;
constructor (address tokenAdd) public {
}
function setPresaleTime(uint256 time) external onlyOwner() {
}
function setPresaleFlag(bool flag) external onlyOwner() {
}
function setPresalePrice(uint256 priceInWei) external onlyOwner() {
require(<FILL_ME>)
presalePrice = priceInWei;
}
// Presale function
receive() external payable {
}
function presaleDone() external onlyOwner() {
}
function emergencyWithdraw() external onlyOwner() {
}
}
| !presale&&!token.isPresaleDone(),"Can only be set before presale starts" | 399,105 | !presale&&!token.isPresaleDone() |
"Presale max cap already reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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 _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library Constants {
uint256 private constant MAX = ~uint256(0);
uint256 private constant _launchSupply = 100000 * 10**9;
uint256 private constant _largeTotal = (MAX - (MAX % _launchSupply));
uint256 private constant _baseExpansionFactor = 100;
uint256 private constant _baseContractionFactor = 100;
uint256 private constant _baseUtilityFee = 50;
uint256 private constant _baseContractionCap = 1000;
uint256 private constant _stabilizerFee = 250;
uint256 private constant _stabilizationLowerBound = 50;
uint256 private constant _stabilizationLowerReset = 75;
uint256 private constant _stabilizationUpperBound = 150;
uint256 private constant _stabilizationUpperReset = 125;
uint256 private constant _stabilizePercent = 10;
uint256 private constant _treasuryFee = 250;
uint256 private constant _presaleMinIndividualCap = 1 ether;
uint256 private constant _presaleMaxIndividualCap = 3 ether;
uint256 private constant _presaleCap = 55000 * 10**9;
uint256 private constant _maxPresaleGas = 200000000000;
uint256 private constant _epochLength = 30 minutes;
uint256 private constant _liquidityReward = 5 * 10**9;
uint256 private constant _minForLiquidity = 20 * 10**9;
uint256 private constant _minForCallerLiquidity = 20 * 10**9;
address private constant _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private constant _factoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address payable private constant _deployerAddress = 0xA5C30116b6E926Ec0F159649c724eE6058F4953D;
address private constant _treasuryAddress = 0xA5C30116b6E926Ec0F159649c724eE6058F4953D;
uint256 private constant _presaleRate = 27500;
uint256 private constant _listingRate = 23333;
string private constant _name = "SpeedXStable";
string private constant _symbol = "SXST";
uint8 private constant _decimals = 9;
/****** Getters *******/
function getPresaleRate() internal pure returns (uint256) {
}
function getListingRate() internal pure returns (uint256) {
}
function getLaunchSupply() internal pure returns (uint256) {
}
function getLargeTotal() internal pure returns (uint256) {
}
function getPresaleCap() internal pure returns (uint256) {
}
function getPresaleMinIndividualCap() internal pure returns (uint256) {
}
function getPresaleMaxIndividualCap() internal pure returns (uint256) {
}
function getMaxPresaleGas() internal pure returns (uint256) {
}
function getBaseExpansionFactor() internal pure returns (uint256) {
}
function getBaseContractionFactor() internal pure returns (uint256) {
}
function getBaseContractionCap() internal pure returns (uint256) {
}
function getBaseUtilityFee() internal pure returns (uint256) {
}
function getStabilizerFee() internal pure returns (uint256) {
}
function getStabilizationLowerBound() internal pure returns (uint256) {
}
function getStabilizationLowerReset() internal pure returns (uint256) {
}
function getStabilizationUpperBound() internal pure returns (uint256) {
}
function getStabilizationUpperReset() internal pure returns (uint256) {
}
function getStabilizePercent() internal pure returns (uint256) {
}
function getTreasuryFee() internal pure returns (uint256) {
}
function getEpochLength() internal pure returns (uint256) {
}
function getLiquidityReward() internal pure returns (uint256) {
}
function getMinForLiquidity() internal pure returns (uint256) {
}
function getMinForCallerLiquidity() internal pure returns (uint256) {
}
function getRouterAdd() internal pure returns (address) {
}
function getFactoryAdd() internal pure returns (address) {
}
function getDeployerAdd() internal pure returns (address payable) {
}
function getTreasuryAdd() internal pure returns (address) {
}
function getName() internal pure returns (string memory) {
}
function getSymbol() internal pure returns (string memory) {
}
function getDecimals() internal pure returns (uint8) {
}
}
interface IXStable {
function isPresaleDone() external view returns (bool);
function mint(address to, uint256 amount) external;
function setPresaleDone() external payable;
}
contract Presale is Context, Ownable {
using SafeMath for uint256;
using Address for address;
IXStable token;
// Presale stuff below
uint256 private _presaleMint;
uint256 public presaleTime = now;
uint256 public presalePrice;
mapping (address => uint256) private _presaleParticipation;
bool public presale = false;
constructor (address tokenAdd) public {
}
function setPresaleTime(uint256 time) external onlyOwner() {
}
function setPresaleFlag(bool flag) external onlyOwner() {
}
function setPresalePrice(uint256 priceInWei) external onlyOwner() {
}
// Presale function
receive() external payable {
require(presale, "Presale is inactive");
require(!token.isPresaleDone(), "Presale is already completed");
require(presaleTime <= now, "Presale hasn't started yet");
uint256 invest = _presaleParticipation[_msgSender()].add(msg.value);
require(invest <= Constants.getPresaleMaxIndividualCap() && invest >= Constants.getPresaleMinIndividualCap(), "Crossed individual cap");
require(presalePrice != 0, "Presale price is not set");
require(msg.value > 0, "Cannot buy without sending any eth mate!");
require(!Address.isContract(_msgSender()),"no contracts");
require(tx.gasprice <= Constants.getMaxPresaleGas(),"gas price above limit");
uint256 amountToMint = msg.value.div(10**11).mul(presalePrice);
require(<FILL_ME>)
token.mint(_msgSender(),amountToMint);
_presaleParticipation[_msgSender()] = _presaleParticipation[_msgSender()].add(msg.value);
_presaleMint = _presaleMint.add(amountToMint);
}
function presaleDone() external onlyOwner() {
}
function emergencyWithdraw() external onlyOwner() {
}
}
| _presaleMint.add(amountToMint)<=Constants.getPresaleCap(),"Presale max cap already reached" | 399,105 | _presaleMint.add(amountToMint)<=Constants.getPresaleCap() |
INVALID_STATE_CHANGE | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
/// _ _ _ _ _ _
/// | |_ ___ ___| |_|_|___ ___| | | |_ ___ ___ ___ ___ ___ _____ ___ |_|___
/// | _| .'| _| _| | _| .'| | | _| .'| | . | _| .'| |_ -| _ | | . |
/// |_| |__,|___|_| |_|___|__,|_| |_| |__,|_|_|_ |_| |__,|_|_|_|___| |_| |_|___|
/// |___|
///
/// tacticaltangrams.io
/// _ _ _____ _ _
/// ___ ___ ___| |_ ___ ___ ___| |_ | __| |_ ___| |_ ___
/// | _| . | | _| _| .'| _| _| |__ | _| .'| _| -_|
/// |___|___|_|_|_| |_| |__,|___|_| |_____|_| |__,|_| |___|
/// @title Tactical Tangrams State contract
/// @author tacticaltangrams.io
/// @notice Implements the basis for Tactical Tangram's state machine
abstract contract State {
/// @notice Emit state changes
/// @param oldState Previous state
/// @param newState Current state
event StateChanged(StateType oldState, StateType newState);
/// @notice Change to new state when state change is allowed
/// @dev Virtual methods changeState* have to be implemented. Invalid state changes have to be reverted in each changeState* method
/// @param _from State to change from
/// @param _to State to change to
function changeState(StateType _from, StateType _to) internal
{
require(<FILL_ME>)
bool stateChangeHandled = false;
if (StateType.PREMINT == _to)
{
stateChangeHandled = true;
changeStatePremint();
}
else if (StateType.MINT == _to)
{
stateChangeHandled = true;
changeStateMint();
}
else if (StateType.MINTCLOSED == _to)
{
stateChangeHandled = true;
changeStateMintClosed();
}
// StateType.GENERATIONSTARTED cannot be set over setState, this is done implicitly by processGenerationSeedReceived
else if (StateType.GENERATIONCLOSING == _to)
{
stateChangeHandled = true;
changeStateGenerationClosing();
}
else if (StateType.GENERATIONCLOSED == _to)
{
stateChangeHandled = true;
changeStateGenerationClosed();
}
require(
stateChangeHandled,
INVALID_STATE_CHANGE
);
state = _to;
emit StateChanged(_from, _to);
if (StateType.MINTCLOSED == _to) {
changeStateMintClosedAfter();
}
}
function changeStatePremint() internal virtual;
function changeStateMint() internal virtual;
function changeStateMintClosed() internal virtual;
function changeStateMintClosedAfter() internal virtual;
function changeStateGenerationStarted() internal virtual;
function changeStateGenerationClosing() internal virtual;
function changeStateGenerationClosed() internal virtual;
/// @notice Verify allowed states
/// @param _either Allowed state
/// @param _or Allowed state
modifier inEitherState(StateType _either, StateType _or) {
}
/// @notice Verify allowed state
/// @param _state Allowed state
modifier inState(StateType _state) {
}
/// @notice Verify allowed minimum state
/// @param _state Minimum allowed state
modifier inStateOrAbove(StateType _state) {
}
/// @notice List of states for Tactical Tangrams
/// @dev When in states GENERATIONSTARTED, GENERATIONCLOSING or GENERATIONCLOSED, Tan.currentGeneration indicates the current state
enum StateType
{
ALL ,
DEPLOYED , // contract has been deployed
PREMINT , // only OG and WL minting allowed
MINT , // only public minting allowed
MINTCLOSED , // no more minting allowed; total mint income stored, random seed for gen 1 requested
GENERATIONSTARTED , // random seed available, Tans revealed
GENERATIONCLOSING , // 80-100% Tans swapped
GENERATIONCLOSED // 100% Tans swapped, random seed for next generation requested for gen < 7
}
StateType public state = StateType.DEPLOYED;
string private constant INVALID_STATE = "Invalid state";
string private constant INVALID_STATE_CHANGE = "Invalid state change";
}
| (_from!=_to)&&(StateType.ALL==_from||state==_from),INVALID_STATE_CHANGE | 399,126 | (_from!=_to)&&(StateType.ALL==_from||state==_from) |
INVALID_STATE | // SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
/// _ _ _ _ _ _
/// | |_ ___ ___| |_|_|___ ___| | | |_ ___ ___ ___ ___ ___ _____ ___ |_|___
/// | _| .'| _| _| | _| .'| | | _| .'| | . | _| .'| |_ -| _ | | . |
/// |_| |__,|___|_| |_|___|__,|_| |_| |__,|_|_|_ |_| |__,|_|_|_|___| |_| |_|___|
/// |___|
///
/// tacticaltangrams.io
/// _ _ _____ _ _
/// ___ ___ ___| |_ ___ ___ ___| |_ | __| |_ ___| |_ ___
/// | _| . | | _| _| .'| _| _| |__ | _| .'| _| -_|
/// |___|___|_|_|_| |_| |__,|___|_| |_____|_| |__,|_| |___|
/// @title Tactical Tangrams State contract
/// @author tacticaltangrams.io
/// @notice Implements the basis for Tactical Tangram's state machine
abstract contract State {
/// @notice Emit state changes
/// @param oldState Previous state
/// @param newState Current state
event StateChanged(StateType oldState, StateType newState);
/// @notice Change to new state when state change is allowed
/// @dev Virtual methods changeState* have to be implemented. Invalid state changes have to be reverted in each changeState* method
/// @param _from State to change from
/// @param _to State to change to
function changeState(StateType _from, StateType _to) internal
{
}
function changeStatePremint() internal virtual;
function changeStateMint() internal virtual;
function changeStateMintClosed() internal virtual;
function changeStateMintClosedAfter() internal virtual;
function changeStateGenerationStarted() internal virtual;
function changeStateGenerationClosing() internal virtual;
function changeStateGenerationClosed() internal virtual;
/// @notice Verify allowed states
/// @param _either Allowed state
/// @param _or Allowed state
modifier inEitherState(StateType _either, StateType _or) {
require(<FILL_ME>)
_;
}
/// @notice Verify allowed state
/// @param _state Allowed state
modifier inState(StateType _state) {
}
/// @notice Verify allowed minimum state
/// @param _state Minimum allowed state
modifier inStateOrAbove(StateType _state) {
}
/// @notice List of states for Tactical Tangrams
/// @dev When in states GENERATIONSTARTED, GENERATIONCLOSING or GENERATIONCLOSED, Tan.currentGeneration indicates the current state
enum StateType
{
ALL ,
DEPLOYED , // contract has been deployed
PREMINT , // only OG and WL minting allowed
MINT , // only public minting allowed
MINTCLOSED , // no more minting allowed; total mint income stored, random seed for gen 1 requested
GENERATIONSTARTED , // random seed available, Tans revealed
GENERATIONCLOSING , // 80-100% Tans swapped
GENERATIONCLOSED // 100% Tans swapped, random seed for next generation requested for gen < 7
}
StateType public state = StateType.DEPLOYED;
string private constant INVALID_STATE = "Invalid state";
string private constant INVALID_STATE_CHANGE = "Invalid state change";
}
| (state==_either)||(state==_or),INVALID_STATE | 399,126 | (state==_either)||(state==_or) |
null | pragma solidity ^0.4.21;
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
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);
}
/**
* @title ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/20
*/
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);
}
/**
* @title Basic token
* @dev Basic version of StandardToken, with no allowances.
*/
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 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 balance) {
}
}
/**
* @title Standard ERC20 token
*
* @dev Implementation of the basic standard token.
* @dev https://github.com/ethereum/EIPs/issues/20
* @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
*/
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, uint _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, uint _subtractedValue) public returns (bool) {
}
}
/**
* @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) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts 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) {
}
}
/**
* @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 {
}
}
contract ExchangeRate is Ownable {
event RateUpdated(uint timestamp, bytes32 symbol, uint rate);
mapping(bytes32 => uint) public rates;
/**
* @dev Allows the current owner to update a single rate.
* @param _symbol The symbol to be updated.
* @param _rate the rate for the symbol.
*/
function updateRate(string _symbol, uint _rate) public onlyOwner {
}
/**
* @dev Allows the current owner to update multiple rates.
* @param data an array that alternates sha3 hashes of the symbol and the corresponding rate .
*/
function updateRates(uint[] data) public onlyOwner {
}
/**
* @dev Allows the anyone to read the current rate.
* @param _symbol the symbol to be retrieved.
*/
function getRate(string _symbol) public constant returns(uint) {
}
}
/**
* @title Mintable token
* @dev Simple ERC20 Token example, with mintable token creation
* @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
* Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
*/
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
}
/**
* @dev Function to mint tokens
* @param _to The address that will receive the minted tokens.
* @param _amount The amount of tokens to mint.
* @return A boolean that indicates if the operation was successful.
*/
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
}
/**
* @dev Function to stop minting new tokens.
* @return True if the operation was successful.
*/
function finishMinting() onlyOwner canMint public returns (bool) {
}
}
contract SmartCoinFerma is MintableToken {
string public constant name = "Smart Coin Ferma";
string public constant symbol = "SCF";
uint32 public constant decimals = 8;
HoldersList public list = new HoldersList();
bool public tradingStarted = true;
/**
* @dev modifier that throws if trading has not started yet
*/
modifier hasStartedTrading() {
}
/**
* @dev Allows the owner to enable the trading. This can not be undone
*/
function startTrading() public onlyOwner {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @param _to the recipient address of the tokens.
* @param _value number of tokens to be transfered.
*/
function transfer(address _to, uint _value) hasStartedTrading public returns (bool) {
}
/**
* @dev Allows anyone to transfer the PAY tokens once trading has started
* @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 uint the amout of tokens to be transfered
*/
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
}
function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) {
}
}
contract HoldersList is Ownable{
uint256 public _totalTokens;
struct TokenHolder {
uint256 balance;
uint regTime;
bool isValue;
}
mapping(address => TokenHolder) holders;
address[] public payees;
function changeBalance(address _who, uint _amount) public onlyOwner {
}
function notInArray(address _who) internal view returns (bool) {
}
/**
* @dev Defines number of issued tokens.
*/
function setTotal(uint _amount) public onlyOwner {
}
/**
* @dev Returnes number of issued tokens.
*/
function getTotal() public constant returns (uint) {
}
/**
* @dev Returnes holders balance.
*/
function returnBalance (address _who) public constant returns (uint){
}
/**
* @dev Returnes number of holders in array.
*/
function returnPayees () public constant returns (uint){
}
/**
* @dev Returnes holders address.
*/
function returnHolder (uint _num) public constant returns (address){
}
/**
* @dev Returnes registration date of holder.
*/
function returnRegDate (address _who) public constant returns (uint){
}
}
contract Crowdsale is Ownable {
using SafeMath for uint;
event TokenSold(address recipient, uint ether_amount, uint pay_amount, uint exchangerate);
event AuthorizedCreate(address recipient, uint pay_amount);
SmartCoinFerma public token = new SmartCoinFerma();
//prod
address multisigVaultFirst = 0xAD7C50cfeb60B6345cb428c5820eD073f35283e7;
address multisigVaultSecond = 0xA9B04eF1901A0d720De14759bC286eABC344b3BA;
address multisigVaultThird = 0xF1678Cc0727b354a9B0612dd40D275a3BBdE5979;
uint restrictedPercent = 50;
bool pause = false;
//prod
address restricted = 0x217d44b5c4bffC5421bd4bb9CC85fBf61d3fbdb6;
address restrictedAdditional = 0xF1678Cc0727b354a9B0612dd40D275a3BBdE5979;
ExchangeRate exchangeRate;
uint public start = 1523491200;
uint period = 365;
uint _rate;
/**
* @dev modifier to allow token creation only when the sale IS ON
*/
modifier saleIsOn() {
}
/**
* @dev Allows owner to pause the crowdsale
*/
function setPause( bool _newPause ) onlyOwner public {
}
/**
* @dev Allows anyone to create tokens by depositing ether.
* @param recipient the recipient to receive tokens.
*/
function createTokens(address recipient) saleIsOn payable {
uint256 sum;
uint256 halfSum;
uint256 quatSum;
uint256 rate;
uint256 tokens;
uint256 restrictedTokens;
uint256 tok1;
uint256 tok2;
require( msg.value > 0 );
sum = msg.value;
halfSum = sum.div(2);
quatSum = halfSum.div(2);
rate = exchangeRate.getRate("ETH");
tokens = rate.mul(sum).div(1 ether);
require( tokens > 0 );
token.mint(recipient, tokens);
multisigVaultFirst.transfer(halfSum);
multisigVaultSecond.transfer(quatSum);
multisigVaultThird.transfer(quatSum);
/*
* "dev Create restricted tokens
*/
restrictedTokens = tokens.mul(restrictedPercent).div(100 - restrictedPercent);
tok1 = restrictedTokens.mul(60).div(100);
tok2 = restrictedTokens.mul(40).div(100);
require(<FILL_ME>)
token.mint(restricted, tok1);
token.mint(restrictedAdditional, tok2);
emit TokenSold(recipient, msg.value, tokens, rate);
}
/**
* @dev Allows the owner to set the starting time.
* @param _start the new _start
*/
function setStart(uint _start) public onlyOwner {
}
/**
* @dev Allows the owner to set the exchangerate contract.
* @param _exchangeRate the exchangerate address
*/
function setExchangeRate(address _exchangeRate) public onlyOwner {
}
/**
* @dev Allows the owner to finish the minting. This will create the
* restricted tokens and then close the minting.
* Then the ownership of the PAY token contract is transfered
* to this owner.
*/
function finishMinting() public onlyOwner {
}
/**
* @dev Fallback function which receives ether and created the appropriate number of tokens for the
* msg.sender.
*/
function() external payable {
}
}
| tok1+tok2==restrictedTokens | 399,187 | tok1+tok2==restrictedTokens |
"Incorrect Ether value." | pragma solidity ^0.8.0;
// SPDX-License-Identifier: MIT
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev 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 {
}
}
contract PropertySniper is Ownable {
// Structs for gas optimization
struct Subscription {
uint256 price;
uint256 time;
}
struct User {
uint256 end_of_subscription;
}
uint256 constant private DAY_SECONDS = 86400;
uint private currentPrice = 100;
address payable public treasury;
uint maxNumberOfUsers = 25;
uint whitelistCount;
mapping(address => User) private users;
mapping(address => bool) private whitelisted;
mapping(uint => Subscription) private subscriptionOptions;
address[] currentlySubscribedAddresses;
bool activeSale = false;
constructor() {
}
function setTreasury(address payable _treasury) external onlyOwner {
}
function setBasePrice(uint256 _index, uint256 _price) external onlyOwner {
}
function getSubscriptionLength(uint256 _index) external view returns(uint256) {
}
function setSubscriptionLength(uint256 _index, uint256 _timeInDays) external onlyOwner {
}
function subscribe(address payable _referrer, uint256 _subscriptionIndex) external payable {
require(treasury != address(0), "Treasury not set yet.");
require(<FILL_ME>)
require(activeSale, "Sale is not active. Check Discord or Twitter for updates.");
if(!whitelisted[msg.sender]) {
require(updateAndReturnNumberOfSubscribers() < maxNumberOfUsers, "Max number of users reached.");
}
User storage user = users[msg.sender];
if (user.end_of_subscription == 0) {
users[msg.sender] = User(block.timestamp + subscriptionOptions[_subscriptionIndex].time);
whitelistCount++;
currentlySubscribedAddresses.push(msg.sender);
} else if (getTimeUntilSubscriptionExpired(msg.sender) <= 0) {
user.end_of_subscription = block.timestamp + subscriptionOptions[_subscriptionIndex].time;
whitelistCount++;
currentlySubscribedAddresses.push(msg.sender);
} else {
user.end_of_subscription += subscriptionOptions[_subscriptionIndex].time;
}
// Whitelist the user
whitelisted[msg.sender] = true;
// Never hold Ether in the contract. Directly transfer 5% to the referrer, 95% to the treasury wallet.
if (_referrer == address(0)) {
treasury.transfer(msg.value);
} else {
_referrer.transfer(msg.value * 5 / 100);
treasury.transfer(msg.value * 95 / 100);
}
}
function getAllSubscriptionPlans() external view returns(Subscription[] memory) {
}
function discount(uint _amountAsAPercent) external onlyOwner {
}
function getCurrentPrice() internal view returns(uint) {
}
function getSubscriptionPlanPrice(uint _index) external view returns(uint256) {
}
function setMaxNumberOfUsers(uint _numberOfUsers) external onlyOwner {
}
function getMaxNumberOfUsers() external view returns(uint) {
}
function addUserToWhitelist(address _address, uint _subscriptionLengthInSeconds) external onlyOwner {
}
function getTimeUntilSubscriptionExpired(address _address) public view returns(int256) {
}
function updateAndReturnNumberOfSubscribers() public returns(uint) {
}
function efficientRemove(uint _index) internal {
}
function getWhitelistedAddresses() external view returns(address[] memory) {
}
function removeAddressFromWhitelist(address _address) external onlyOwner {
}
function getActiveSale() external view returns(bool) {
}
function setActiveSale(bool _activeSale) external onlyOwner {
}
function getNumberOfWhitelistedUsers() external view returns(uint) {
}
}
| subscriptionOptions[_subscriptionIndex].price*currentPrice/100==msg.value,"Incorrect Ether value." | 399,309 | subscriptionOptions[_subscriptionIndex].price*currentPrice/100==msg.value |
"Max number of users reached." | pragma solidity ^0.8.0;
// SPDX-License-Identifier: MIT
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev 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 {
}
}
contract PropertySniper is Ownable {
// Structs for gas optimization
struct Subscription {
uint256 price;
uint256 time;
}
struct User {
uint256 end_of_subscription;
}
uint256 constant private DAY_SECONDS = 86400;
uint private currentPrice = 100;
address payable public treasury;
uint maxNumberOfUsers = 25;
uint whitelistCount;
mapping(address => User) private users;
mapping(address => bool) private whitelisted;
mapping(uint => Subscription) private subscriptionOptions;
address[] currentlySubscribedAddresses;
bool activeSale = false;
constructor() {
}
function setTreasury(address payable _treasury) external onlyOwner {
}
function setBasePrice(uint256 _index, uint256 _price) external onlyOwner {
}
function getSubscriptionLength(uint256 _index) external view returns(uint256) {
}
function setSubscriptionLength(uint256 _index, uint256 _timeInDays) external onlyOwner {
}
function subscribe(address payable _referrer, uint256 _subscriptionIndex) external payable {
require(treasury != address(0), "Treasury not set yet.");
require(subscriptionOptions[_subscriptionIndex].price * currentPrice / 100 == msg.value, "Incorrect Ether value.");
require(activeSale, "Sale is not active. Check Discord or Twitter for updates.");
if(!whitelisted[msg.sender]) {
require(<FILL_ME>)
}
User storage user = users[msg.sender];
if (user.end_of_subscription == 0) {
users[msg.sender] = User(block.timestamp + subscriptionOptions[_subscriptionIndex].time);
whitelistCount++;
currentlySubscribedAddresses.push(msg.sender);
} else if (getTimeUntilSubscriptionExpired(msg.sender) <= 0) {
user.end_of_subscription = block.timestamp + subscriptionOptions[_subscriptionIndex].time;
whitelistCount++;
currentlySubscribedAddresses.push(msg.sender);
} else {
user.end_of_subscription += subscriptionOptions[_subscriptionIndex].time;
}
// Whitelist the user
whitelisted[msg.sender] = true;
// Never hold Ether in the contract. Directly transfer 5% to the referrer, 95% to the treasury wallet.
if (_referrer == address(0)) {
treasury.transfer(msg.value);
} else {
_referrer.transfer(msg.value * 5 / 100);
treasury.transfer(msg.value * 95 / 100);
}
}
function getAllSubscriptionPlans() external view returns(Subscription[] memory) {
}
function discount(uint _amountAsAPercent) external onlyOwner {
}
function getCurrentPrice() internal view returns(uint) {
}
function getSubscriptionPlanPrice(uint _index) external view returns(uint256) {
}
function setMaxNumberOfUsers(uint _numberOfUsers) external onlyOwner {
}
function getMaxNumberOfUsers() external view returns(uint) {
}
function addUserToWhitelist(address _address, uint _subscriptionLengthInSeconds) external onlyOwner {
}
function getTimeUntilSubscriptionExpired(address _address) public view returns(int256) {
}
function updateAndReturnNumberOfSubscribers() public returns(uint) {
}
function efficientRemove(uint _index) internal {
}
function getWhitelistedAddresses() external view returns(address[] memory) {
}
function removeAddressFromWhitelist(address _address) external onlyOwner {
}
function getActiveSale() external view returns(bool) {
}
function setActiveSale(bool _activeSale) external onlyOwner {
}
function getNumberOfWhitelistedUsers() external view returns(uint) {
}
}
| updateAndReturnNumberOfSubscribers()<maxNumberOfUsers,"Max number of users reached." | 399,309 | updateAndReturnNumberOfSubscribers()<maxNumberOfUsers |
null | pragma solidity > 0.6.0;
// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
}
function safeTransfer(address token, address to, uint value) internal {
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
}
function safeTransferETH(address to, uint value) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
}
contract AdminAccount {
using SafeMath for uint256;
uint256 public constant MAG = 10 ** 18;
address[] public ambassadorList = [0xd865697A2aCbBdf280EDD19d81FA1D9a4885a15e,
0x13216D1A245A3dF60cFcE85A84c5fe84b1706fd7,
0x0799442CE0f90F8837fdeEce82Cd2735625B4bf9];
mapping(address => uint256) public shares;
modifier isAmbassador() {
require(<FILL_ME>)
_;
}
constructor() public {
}
function disburseFees(address _token) isAmbassador external {
}
}
/**
* @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) {
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Substracts 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) {
}
}
| shares[msg.sender]>uint256(0) | 399,424 | shares[msg.sender]>uint256(0) |
"Sold out" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract InvisiblePhriends is ERC721, ERC721Enumerable {
bool public saleIsActive = false;
string public _baseUri = "ipfs://QmbzHGJDKVZ22TE6VsixdmMPgbR5QamCfpuKV8jF826NVe/";
uint public _mint = 0.0069 ether;
address public owner;
constructor() ERC721("InvisiblePhriends", "IPH") {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
modifier onlyOwner {
}
function transferOwnership (address newOwner) public onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view override returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setSaleState(bool newState) public onlyOwner {
}
function mintPrice(uint8 newMint) public onlyOwner {
}
function mintTokens(uint numberOfTokens) public payable {
require(saleIsActive, "Sale must be active to mint Tokens");
require(numberOfTokens <= 20, "Exceeded max token purchase");
require(<FILL_ME>)
if(totalSupply() + numberOfTokens > 1000){
require(_mint * numberOfTokens == msg.value, "Ether value sent is not correct");
}
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply();
if (totalSupply() <= 5000) {
_safeMint(msg.sender, mintIndex);
}
}
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+numberOfTokens<=5000,"Sold out" | 399,450 | totalSupply()+numberOfTokens<=5000 |
"Ether value sent is not correct" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract InvisiblePhriends is ERC721, ERC721Enumerable {
bool public saleIsActive = false;
string public _baseUri = "ipfs://QmbzHGJDKVZ22TE6VsixdmMPgbR5QamCfpuKV8jF826NVe/";
uint public _mint = 0.0069 ether;
address public owner;
constructor() ERC721("InvisiblePhriends", "IPH") {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
}
modifier onlyOwner {
}
function transferOwnership (address newOwner) public onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view override returns(string memory) {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
function setSaleState(bool newState) public onlyOwner {
}
function mintPrice(uint8 newMint) public onlyOwner {
}
function mintTokens(uint numberOfTokens) public payable {
require(saleIsActive, "Sale must be active to mint Tokens");
require(numberOfTokens <= 20, "Exceeded max token purchase");
require(totalSupply() + numberOfTokens <= 5000, "Sold out");
if(totalSupply() + numberOfTokens > 1000){
require(<FILL_ME>)
}
for(uint i = 0; i < numberOfTokens; i++) {
uint mintIndex = totalSupply();
if (totalSupply() <= 5000) {
_safeMint(msg.sender, mintIndex);
}
}
}
function withdraw() public onlyOwner {
}
}
| _mint*numberOfTokens==msg.value,"Ether value sent is not correct" | 399,450 | _mint*numberOfTokens==msg.value |
null | pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
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() {
}
/**
* @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 {
}
}
contract Claimable is Ownable {
address public pendingOwner;
/**
* @dev Modifier throws if called by any account other than the pendingOwner.
*/
modifier onlyPendingOwner() {
}
/**
* @dev Allows the current owner to set the pendingOwner address.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the pendingOwner address to finalize the transfer.
*/
function claimOwnership() onlyPendingOwner public {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract PresaleOracles is Claimable {
/*
* PresaleOracles
* Simple Presale contract
* built by github.com/rstormsf Roman Storm
*/
using SafeMath for uint256;
uint256 public startTime;
uint256 public endTime;
uint256 public cap;
uint256 public totalInvestedInWei;
uint256 public minimumContribution;
mapping(address => uint256) public investorBalances;
mapping(address => bool) public whitelist;
uint256 public investorsLength;
address public vault;
bool public isInitialized = false;
// TESTED by Roman Storm
function () public payable {
}
//TESTED by Roman Storm
function Presale() public {
}
//TESTED by Roman Storm
function initialize(uint256 _startTime, uint256 _endTime, uint256 _cap, uint256 _minimumContribution, address _vault) public onlyOwner {
}
//TESTED by Roman Storm
event Contribution(address indexed investor, uint256 investorAmount, uint256 investorTotal, uint256 totalAmount);
function buy() public payable {
require(whitelist[msg.sender]);
require(<FILL_ME>)
require(isInitialized);
require(getTime() >= startTime && getTime() <= endTime);
address investor = msg.sender;
investorBalances[investor] += msg.value;
totalInvestedInWei += msg.value;
forwardFunds(msg.value);
Contribution(msg.sender, msg.value, investorBalances[investor], totalInvestedInWei);
}
//TESTED by Roman Storm
function forwardFunds(uint256 _amount) internal {
}
//TESTED by Roman Storm
function claimTokens(address _token) public onlyOwner {
}
function getTime() internal view returns(uint256) {
}
//TESTED by Roman Storm
function isValidPurchase(uint256 _amount) public view returns(bool) {
}
//TESTED by Roman Storm
function whitelistInvestor(address _newInvestor) public onlyOwner {
}
//TESTED by Roman Storm
function whitelistInvestors(address[] _investors) external onlyOwner {
}
function blacklistInvestor(address _investor) public onlyOwner {
}
}
| isValidPurchase(msg.value) | 399,465 | isValidPurchase(msg.value) |
null | pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
}
}
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() {
}
/**
* @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 {
}
}
contract Claimable is Ownable {
address public pendingOwner;
/**
* @dev Modifier throws if called by any account other than the pendingOwner.
*/
modifier onlyPendingOwner() {
}
/**
* @dev Allows the current owner to set the pendingOwner address.
* @param newOwner The address to transfer ownership to.
*/
function transferOwnership(address newOwner) onlyOwner public {
}
/**
* @dev Allows the pendingOwner address to finalize the transfer.
*/
function claimOwnership() onlyPendingOwner public {
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract PresaleOracles is Claimable {
/*
* PresaleOracles
* Simple Presale contract
* built by github.com/rstormsf Roman Storm
*/
using SafeMath for uint256;
uint256 public startTime;
uint256 public endTime;
uint256 public cap;
uint256 public totalInvestedInWei;
uint256 public minimumContribution;
mapping(address => uint256) public investorBalances;
mapping(address => bool) public whitelist;
uint256 public investorsLength;
address public vault;
bool public isInitialized = false;
// TESTED by Roman Storm
function () public payable {
}
//TESTED by Roman Storm
function Presale() public {
}
//TESTED by Roman Storm
function initialize(uint256 _startTime, uint256 _endTime, uint256 _cap, uint256 _minimumContribution, address _vault) public onlyOwner {
}
//TESTED by Roman Storm
event Contribution(address indexed investor, uint256 investorAmount, uint256 investorTotal, uint256 totalAmount);
function buy() public payable {
require(whitelist[msg.sender]);
require(isValidPurchase(msg.value));
require(isInitialized);
require(<FILL_ME>)
address investor = msg.sender;
investorBalances[investor] += msg.value;
totalInvestedInWei += msg.value;
forwardFunds(msg.value);
Contribution(msg.sender, msg.value, investorBalances[investor], totalInvestedInWei);
}
//TESTED by Roman Storm
function forwardFunds(uint256 _amount) internal {
}
//TESTED by Roman Storm
function claimTokens(address _token) public onlyOwner {
}
function getTime() internal view returns(uint256) {
}
//TESTED by Roman Storm
function isValidPurchase(uint256 _amount) public view returns(bool) {
}
//TESTED by Roman Storm
function whitelistInvestor(address _newInvestor) public onlyOwner {
}
//TESTED by Roman Storm
function whitelistInvestors(address[] _investors) external onlyOwner {
}
function blacklistInvestor(address _investor) public onlyOwner {
}
}
| getTime()>=startTime&&getTime()<=endTime | 399,465 | getTime()>=startTime&&getTime()<=endTime |
"Redeem: max redeem per transaction reached" | // SPDX-License-Identifier: MIT
/*
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWMMMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWMMWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWMMWWMWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMM
MMMMMMMMMMMMMMMWX0XWWNMMMWWMMMMMMMMMMMMMMMMMMMMMWWNNNXXXKKXNWMMMMWWMMMWMWMMMMMMMMMMMMMMMMMMNKK00OkOXMMWOllcc::oXWWWWWWWWWWWWWWWWWWMMMMMMMMMM
MMMMMMMMMMMMMMXo,,,;;dNMO:,;;::ccllooddxkOXWWk:;,,''.......':dXMMNOxxkkkkOO0000klcc::;:OMM0;... cNMK, '0WNK0OkkOO0XWWWWWWWWMMMMMMMMM
MMMMMMMMMMMMMMO..:. ;OWMo .cOc ;0MO' ... cNMx. 'OMO. ,ko,. ..,cxKWWWWWMMMMMMMM
MMMMMMMMMMMMMMXdlcc::kWWc ... .. .. .l: lWk. '0Md oWk. . .dNWWWWMMMMMMM
MMMMMMMMMMMMMMMMMMMOcOMWd,,':xKKxook0c :KO, ;Xx. .:lcc:' .dWl ;Xx. .lO: '0WWWWMMMMMMM
MMMMMMMMMMMMMMOlloolc0MXc...;dOOxxx0Xl. .cc. cNd ;XMMMM0, cXc .Od .OWd. .OWWWWWMMMMMM
MMMMMMMMMMMMMM0d: .cdKM0' .:co: 'c. .c0Wo ,OKKXWWl 'Oc oo 'dkkxddolkNWWWWWMMMMMM
MMMMMMMMMMMMMNx:' .lkNMk. .'lKK; .l0Nc ....xWO' .l; ,; cc. .;dKWWWWWWWWWWWMMMMM
MMMMMMMMMMMMMXocddddONMx. cKMMN: . .kc oWNc . .;. .kWOl. .cONWWWWWWWWMMMMM
MMMMMMMMMMMMMO.'dkkOXMMo 'xNWl :Ko. c; ,olloKMMk. :0: .dXXNKx:. .oNWWWWWWWMMMMM
MMMMMMMMMMMMMx..::::kWWx'..'cxxxdc;c:. lNo :N0, .. .xMWMMMMMN: cNx. ...',;d0o. .kWWWWWWWMMMMM
MMMMMMMMMMMMMOckMMNXWMNd'',:xKNWXOkKXo. '0x. ,KX; .kMWMMMMMMx. oWX: :XWl .dWWWWWWWMMMMM
MMMMMMMMMMMMMo'oodo,kMK; .''',;,'. ;Xk. '0Nc ';:::xNMMX; .xMWk. :XK; .kWWWWWWWMMMMM
MMMMMMMMMMMMWo......kM0' ;0M0' ,0Wx'.''',. ;KMMWd. ..;0MMNx;;::ccllol' .. :XWWWWWWWMMMMM
MMMMMMMMMMMMMN00OOk0NMNxlcc::;;,'''.....'cxNMMW0xxkOOOKWMWNXNNWW0c;,,'''''.....lNMMMNkxxkkO00KXWMMMMMMMMMMMMMWXx:.. .'lKWWWWWWWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWNNXXKXWMMMMMMMMMMMMMMMMWMMMMMMWWWWWWWNNNNXXXXNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMWN0kxdooodx0XWWWWWWWWWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWMMMMMM
Dev by @bitcoinski
*/
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import "./ICollectible.sol";
import "hardhat/console.sol";
/*
* @title ERC721 token for Collectible, redeemable through burning MintPass tokens
*/
contract Collectible is ICollectible, AccessControl, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private generalCounter;
mapping(uint256 => TokenData) public tokenData;
mapping(uint256 => RedemptionWindow) public redemptionWindows;
struct TokenData {
string tokenURI;
bool exists;
}
struct RedemptionWindow {
uint256 windowOpens;
uint256 windowCloses;
uint256 maxRedeemPerTxn;
}
struct SaleConfig {
bool isSaleOpen;
uint256 windowOpens;
uint256 windowCloses;
uint256 maxMintsPerTxn;
uint256 mintPrice;
uint256 maxSupply;
}
SaleConfig public saleConfiguration;
string private baseTokenURI;
string public _contractURI;
MintPassFactory public mintPassFactory;
event Redeemed(address indexed account, string tokens);
event Minted(address indexed account, string tokens);
/**
* @notice Constructor to create Collectible
*
* @param _symbol the token symbol
* @param _mpIndexes the mintpass indexes to accommodate
* @param _redemptionWindowsOpen the mintpass redemption window open unix timestamp by index
* @param _redemptionWindowsClose the mintpass redemption window close unix timestamp by index
* @param _maxRedeemPerTxn the max mint per redemption by index
* @param _baseTokenURI the respective base URI
* @param _contractMetaDataURI the respective contract meta data URI
* @param _mintPassToken contract address of MintPass token to be burned
*/
constructor (
string memory _name,
string memory _symbol,
uint256[] memory _mpIndexes,
uint256[] memory _redemptionWindowsOpen,
uint256[] memory _redemptionWindowsClose,
uint256[] memory _maxRedeemPerTxn,
string memory _baseTokenURI,
string memory _contractMetaDataURI,
address _mintPassToken
) ERC721(_name, _symbol) {
}
/**
* @notice Set the mintpass contract address
*
* @param _mintPassToken the respective Mint Pass contract address
*/
function setMintPassToken(address _mintPassToken) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Change the base URI for returning metadata
*
* @param _baseTokenURI the respective base URI
*/
function setBaseURI(string memory _baseTokenURI) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Pause redeems until unpause is called
*/
function pause() external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Unpause redeems until pause is called
*/
function unpause() external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure time to enable redeem functionality
*
* @param _windowOpen UNIX timestamp for redeem start
*/
function setRedeemStart(uint256 passID, uint256 _windowOpen) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure time to enable redeem functionality
*
* @param _windowClose UNIX timestamp for redeem close
*/
function setRedeemClose(uint256 passID, uint256 _windowClose) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure the max amount of passes that can be redeemed in a txn for a specific pass index
*
* @param _maxRedeemPerTxn number of passes that can be redeemed
*/
function setMaxRedeemPerTxn(uint256 passID, uint256 _maxRedeemPerTxn) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Check if redemption window is open
*
* @param passID the pass index to check
*/
function isRedemptionOpen(uint256 passID) public view override returns (bool) {
}
/**
* @notice Redeem specified amount of MintPass tokens
*
* @param mpIndexes the tokenIDs of MintPasses to redeem
* @param amounts the amount of MintPasses to redeem
*/
function redeem(uint256[] calldata mpIndexes, uint256[] calldata amounts) external override{
require(msg.sender == tx.origin, "Redeem: not allowed from contract");
require(!paused(), "Redeem: paused");
//check to make sure all are valid then re-loop for redemption
for(uint256 i = 0; i < mpIndexes.length; i++) {
require(amounts[i] > 0, "Redeem: amount cannot be zero");
require(<FILL_ME>)
require(mintPassFactory.balanceOf(msg.sender, mpIndexes[i]) >= amounts[i], "Redeem: insufficient amount of Mint Passes");
require(block.timestamp > redemptionWindows[mpIndexes[i]].windowOpens, "Redeem: redeption window not open for this Mint Pass");
require(block.timestamp < redemptionWindows[mpIndexes[i]].windowCloses, "Redeem: redeption window is closed for this Mint Pass");
}
string memory tokens = "";
for(uint256 i = 0; i < mpIndexes.length; i++) {
mintPassFactory.burnFromRedeem(msg.sender, mpIndexes[i], amounts[i]);
for(uint256 j = 0; j < amounts[i]; j++) {
_safeMint(msg.sender, generalCounter.current());
tokens = string(abi.encodePacked(tokens, generalCounter.current().toString(), ","));
generalCounter.increment();
}
}
emit Redeemed(msg.sender, tokens);
}
function toggleSaleOn(bool isOn) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function editSale(
bool isOn,
uint256 windowOpens,
uint256 windowCloses,
uint256 maxMintsPerTxn,
uint256 mintPrice,
uint256 maxSupply
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function directMint(
uint256 quantity
) external payable {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControl,IERC165, ERC721, ERC721Enumerable) returns (bool) {
}
/**
* @notice Configure the max amount of passes that can be redeemed in a txn for a specific pass index
*
* @param id of token
* @param uri to point the token to
*/
function setIndividualTokenURI(uint256 id, string memory uri) external override onlyRole(DEFAULT_ADMIN_ROLE){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function setContractURI(string memory uri) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function contractURI() public view returns (string memory) {
}
}
interface MintPassFactory {
function burnFromRedeem(address account, uint256 id, uint256 amount) external;
function balanceOf(address account, uint256 id) external view returns (uint256);
}
| amounts[i]<=redemptionWindows[mpIndexes[i]].maxRedeemPerTxn,"Redeem: max redeem per transaction reached" | 399,586 | amounts[i]<=redemptionWindows[mpIndexes[i]].maxRedeemPerTxn |
"Redeem: insufficient amount of Mint Passes" | // SPDX-License-Identifier: MIT
/*
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWMMMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWMMWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWMMWWMWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMM
MMMMMMMMMMMMMMMWX0XWWNMMMWWMMMMMMMMMMMMMMMMMMMMMWWNNNXXXKKXNWMMMMWWMMMWMWMMMMMMMMMMMMMMMMMMNKK00OkOXMMWOllcc::oXWWWWWWWWWWWWWWWWWWMMMMMMMMMM
MMMMMMMMMMMMMMXo,,,;;dNMO:,;;::ccllooddxkOXWWk:;,,''.......':dXMMNOxxkkkkOO0000klcc::;:OMM0;... cNMK, '0WNK0OkkOO0XWWWWWWWWMMMMMMMMM
MMMMMMMMMMMMMMO..:. ;OWMo .cOc ;0MO' ... cNMx. 'OMO. ,ko,. ..,cxKWWWWWMMMMMMMM
MMMMMMMMMMMMMMXdlcc::kWWc ... .. .. .l: lWk. '0Md oWk. . .dNWWWWMMMMMMM
MMMMMMMMMMMMMMMMMMMOcOMWd,,':xKKxook0c :KO, ;Xx. .:lcc:' .dWl ;Xx. .lO: '0WWWWMMMMMMM
MMMMMMMMMMMMMMOlloolc0MXc...;dOOxxx0Xl. .cc. cNd ;XMMMM0, cXc .Od .OWd. .OWWWWWMMMMMM
MMMMMMMMMMMMMM0d: .cdKM0' .:co: 'c. .c0Wo ,OKKXWWl 'Oc oo 'dkkxddolkNWWWWWMMMMMM
MMMMMMMMMMMMMNx:' .lkNMk. .'lKK; .l0Nc ....xWO' .l; ,; cc. .;dKWWWWWWWWWWWMMMMM
MMMMMMMMMMMMMXocddddONMx. cKMMN: . .kc oWNc . .;. .kWOl. .cONWWWWWWWWMMMMM
MMMMMMMMMMMMMO.'dkkOXMMo 'xNWl :Ko. c; ,olloKMMk. :0: .dXXNKx:. .oNWWWWWWWMMMMM
MMMMMMMMMMMMMx..::::kWWx'..'cxxxdc;c:. lNo :N0, .. .xMWMMMMMN: cNx. ...',;d0o. .kWWWWWWWMMMMM
MMMMMMMMMMMMMOckMMNXWMNd'',:xKNWXOkKXo. '0x. ,KX; .kMWMMMMMMx. oWX: :XWl .dWWWWWWWMMMMM
MMMMMMMMMMMMMo'oodo,kMK; .''',;,'. ;Xk. '0Nc ';:::xNMMX; .xMWk. :XK; .kWWWWWWWMMMMM
MMMMMMMMMMMMWo......kM0' ;0M0' ,0Wx'.''',. ;KMMWd. ..;0MMNx;;::ccllol' .. :XWWWWWWWMMMMM
MMMMMMMMMMMMMN00OOk0NMNxlcc::;;,'''.....'cxNMMW0xxkOOOKWMWNXNNWW0c;,,'''''.....lNMMMNkxxkkO00KXWMMMMMMMMMMMMMWXx:.. .'lKWWWWWWWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWNNXXKXWMMMMMMMMMMMMMMMMWMMMMMMWWWWWWWNNNNXXXXNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMWN0kxdooodx0XWWWWWWWWWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWMMMMMM
Dev by @bitcoinski
*/
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import "./ICollectible.sol";
import "hardhat/console.sol";
/*
* @title ERC721 token for Collectible, redeemable through burning MintPass tokens
*/
contract Collectible is ICollectible, AccessControl, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private generalCounter;
mapping(uint256 => TokenData) public tokenData;
mapping(uint256 => RedemptionWindow) public redemptionWindows;
struct TokenData {
string tokenURI;
bool exists;
}
struct RedemptionWindow {
uint256 windowOpens;
uint256 windowCloses;
uint256 maxRedeemPerTxn;
}
struct SaleConfig {
bool isSaleOpen;
uint256 windowOpens;
uint256 windowCloses;
uint256 maxMintsPerTxn;
uint256 mintPrice;
uint256 maxSupply;
}
SaleConfig public saleConfiguration;
string private baseTokenURI;
string public _contractURI;
MintPassFactory public mintPassFactory;
event Redeemed(address indexed account, string tokens);
event Minted(address indexed account, string tokens);
/**
* @notice Constructor to create Collectible
*
* @param _symbol the token symbol
* @param _mpIndexes the mintpass indexes to accommodate
* @param _redemptionWindowsOpen the mintpass redemption window open unix timestamp by index
* @param _redemptionWindowsClose the mintpass redemption window close unix timestamp by index
* @param _maxRedeemPerTxn the max mint per redemption by index
* @param _baseTokenURI the respective base URI
* @param _contractMetaDataURI the respective contract meta data URI
* @param _mintPassToken contract address of MintPass token to be burned
*/
constructor (
string memory _name,
string memory _symbol,
uint256[] memory _mpIndexes,
uint256[] memory _redemptionWindowsOpen,
uint256[] memory _redemptionWindowsClose,
uint256[] memory _maxRedeemPerTxn,
string memory _baseTokenURI,
string memory _contractMetaDataURI,
address _mintPassToken
) ERC721(_name, _symbol) {
}
/**
* @notice Set the mintpass contract address
*
* @param _mintPassToken the respective Mint Pass contract address
*/
function setMintPassToken(address _mintPassToken) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Change the base URI for returning metadata
*
* @param _baseTokenURI the respective base URI
*/
function setBaseURI(string memory _baseTokenURI) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Pause redeems until unpause is called
*/
function pause() external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Unpause redeems until pause is called
*/
function unpause() external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure time to enable redeem functionality
*
* @param _windowOpen UNIX timestamp for redeem start
*/
function setRedeemStart(uint256 passID, uint256 _windowOpen) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure time to enable redeem functionality
*
* @param _windowClose UNIX timestamp for redeem close
*/
function setRedeemClose(uint256 passID, uint256 _windowClose) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure the max amount of passes that can be redeemed in a txn for a specific pass index
*
* @param _maxRedeemPerTxn number of passes that can be redeemed
*/
function setMaxRedeemPerTxn(uint256 passID, uint256 _maxRedeemPerTxn) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Check if redemption window is open
*
* @param passID the pass index to check
*/
function isRedemptionOpen(uint256 passID) public view override returns (bool) {
}
/**
* @notice Redeem specified amount of MintPass tokens
*
* @param mpIndexes the tokenIDs of MintPasses to redeem
* @param amounts the amount of MintPasses to redeem
*/
function redeem(uint256[] calldata mpIndexes, uint256[] calldata amounts) external override{
require(msg.sender == tx.origin, "Redeem: not allowed from contract");
require(!paused(), "Redeem: paused");
//check to make sure all are valid then re-loop for redemption
for(uint256 i = 0; i < mpIndexes.length; i++) {
require(amounts[i] > 0, "Redeem: amount cannot be zero");
require(amounts[i] <= redemptionWindows[mpIndexes[i]].maxRedeemPerTxn, "Redeem: max redeem per transaction reached");
require(<FILL_ME>)
require(block.timestamp > redemptionWindows[mpIndexes[i]].windowOpens, "Redeem: redeption window not open for this Mint Pass");
require(block.timestamp < redemptionWindows[mpIndexes[i]].windowCloses, "Redeem: redeption window is closed for this Mint Pass");
}
string memory tokens = "";
for(uint256 i = 0; i < mpIndexes.length; i++) {
mintPassFactory.burnFromRedeem(msg.sender, mpIndexes[i], amounts[i]);
for(uint256 j = 0; j < amounts[i]; j++) {
_safeMint(msg.sender, generalCounter.current());
tokens = string(abi.encodePacked(tokens, generalCounter.current().toString(), ","));
generalCounter.increment();
}
}
emit Redeemed(msg.sender, tokens);
}
function toggleSaleOn(bool isOn) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function editSale(
bool isOn,
uint256 windowOpens,
uint256 windowCloses,
uint256 maxMintsPerTxn,
uint256 mintPrice,
uint256 maxSupply
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function directMint(
uint256 quantity
) external payable {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControl,IERC165, ERC721, ERC721Enumerable) returns (bool) {
}
/**
* @notice Configure the max amount of passes that can be redeemed in a txn for a specific pass index
*
* @param id of token
* @param uri to point the token to
*/
function setIndividualTokenURI(uint256 id, string memory uri) external override onlyRole(DEFAULT_ADMIN_ROLE){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function setContractURI(string memory uri) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function contractURI() public view returns (string memory) {
}
}
interface MintPassFactory {
function burnFromRedeem(address account, uint256 id, uint256 amount) external;
function balanceOf(address account, uint256 id) external view returns (uint256);
}
| mintPassFactory.balanceOf(msg.sender,mpIndexes[i])>=amounts[i],"Redeem: insufficient amount of Mint Passes" | 399,586 | mintPassFactory.balanceOf(msg.sender,mpIndexes[i])>=amounts[i] |
"Sale: Not started" | // SPDX-License-Identifier: MIT
/*
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWMMMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWMMWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWMMWWMWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMM
MMMMMMMMMMMMMMMWX0XWWNMMMWWMMMMMMMMMMMMMMMMMMMMMWWNNNXXXKKXNWMMMMWWMMMWMWMMMMMMMMMMMMMMMMMMNKK00OkOXMMWOllcc::oXWWWWWWWWWWWWWWWWWWMMMMMMMMMM
MMMMMMMMMMMMMMXo,,,;;dNMO:,;;::ccllooddxkOXWWk:;,,''.......':dXMMNOxxkkkkOO0000klcc::;:OMM0;... cNMK, '0WNK0OkkOO0XWWWWWWWWMMMMMMMMM
MMMMMMMMMMMMMMO..:. ;OWMo .cOc ;0MO' ... cNMx. 'OMO. ,ko,. ..,cxKWWWWWMMMMMMMM
MMMMMMMMMMMMMMXdlcc::kWWc ... .. .. .l: lWk. '0Md oWk. . .dNWWWWMMMMMMM
MMMMMMMMMMMMMMMMMMMOcOMWd,,':xKKxook0c :KO, ;Xx. .:lcc:' .dWl ;Xx. .lO: '0WWWWMMMMMMM
MMMMMMMMMMMMMMOlloolc0MXc...;dOOxxx0Xl. .cc. cNd ;XMMMM0, cXc .Od .OWd. .OWWWWWMMMMMM
MMMMMMMMMMMMMM0d: .cdKM0' .:co: 'c. .c0Wo ,OKKXWWl 'Oc oo 'dkkxddolkNWWWWWMMMMMM
MMMMMMMMMMMMMNx:' .lkNMk. .'lKK; .l0Nc ....xWO' .l; ,; cc. .;dKWWWWWWWWWWWMMMMM
MMMMMMMMMMMMMXocddddONMx. cKMMN: . .kc oWNc . .;. .kWOl. .cONWWWWWWWWMMMMM
MMMMMMMMMMMMMO.'dkkOXMMo 'xNWl :Ko. c; ,olloKMMk. :0: .dXXNKx:. .oNWWWWWWWMMMMM
MMMMMMMMMMMMMx..::::kWWx'..'cxxxdc;c:. lNo :N0, .. .xMWMMMMMN: cNx. ...',;d0o. .kWWWWWWWMMMMM
MMMMMMMMMMMMMOckMMNXWMNd'',:xKNWXOkKXo. '0x. ,KX; .kMWMMMMMMx. oWX: :XWl .dWWWWWWWMMMMM
MMMMMMMMMMMMMo'oodo,kMK; .''',;,'. ;Xk. '0Nc ';:::xNMMX; .xMWk. :XK; .kWWWWWWWMMMMM
MMMMMMMMMMMMWo......kM0' ;0M0' ,0Wx'.''',. ;KMMWd. ..;0MMNx;;::ccllol' .. :XWWWWWWWMMMMM
MMMMMMMMMMMMMN00OOk0NMNxlcc::;;,'''.....'cxNMMW0xxkOOOKWMWNXNNWW0c;,,'''''.....lNMMMNkxxkkO00KXWMMMMMMMMMMMMMWXx:.. .'lKWWWWWWWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWNNXXKXWMMMMMMMMMMMMMMMMWMMMMMMWWWWWWWNNNNXXXXNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMWN0kxdooodx0XWWWWWWWWWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWMMMMMM
Dev by @bitcoinski
*/
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import "./ICollectible.sol";
import "hardhat/console.sol";
/*
* @title ERC721 token for Collectible, redeemable through burning MintPass tokens
*/
contract Collectible is ICollectible, AccessControl, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private generalCounter;
mapping(uint256 => TokenData) public tokenData;
mapping(uint256 => RedemptionWindow) public redemptionWindows;
struct TokenData {
string tokenURI;
bool exists;
}
struct RedemptionWindow {
uint256 windowOpens;
uint256 windowCloses;
uint256 maxRedeemPerTxn;
}
struct SaleConfig {
bool isSaleOpen;
uint256 windowOpens;
uint256 windowCloses;
uint256 maxMintsPerTxn;
uint256 mintPrice;
uint256 maxSupply;
}
SaleConfig public saleConfiguration;
string private baseTokenURI;
string public _contractURI;
MintPassFactory public mintPassFactory;
event Redeemed(address indexed account, string tokens);
event Minted(address indexed account, string tokens);
/**
* @notice Constructor to create Collectible
*
* @param _symbol the token symbol
* @param _mpIndexes the mintpass indexes to accommodate
* @param _redemptionWindowsOpen the mintpass redemption window open unix timestamp by index
* @param _redemptionWindowsClose the mintpass redemption window close unix timestamp by index
* @param _maxRedeemPerTxn the max mint per redemption by index
* @param _baseTokenURI the respective base URI
* @param _contractMetaDataURI the respective contract meta data URI
* @param _mintPassToken contract address of MintPass token to be burned
*/
constructor (
string memory _name,
string memory _symbol,
uint256[] memory _mpIndexes,
uint256[] memory _redemptionWindowsOpen,
uint256[] memory _redemptionWindowsClose,
uint256[] memory _maxRedeemPerTxn,
string memory _baseTokenURI,
string memory _contractMetaDataURI,
address _mintPassToken
) ERC721(_name, _symbol) {
}
/**
* @notice Set the mintpass contract address
*
* @param _mintPassToken the respective Mint Pass contract address
*/
function setMintPassToken(address _mintPassToken) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Change the base URI for returning metadata
*
* @param _baseTokenURI the respective base URI
*/
function setBaseURI(string memory _baseTokenURI) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Pause redeems until unpause is called
*/
function pause() external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Unpause redeems until pause is called
*/
function unpause() external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure time to enable redeem functionality
*
* @param _windowOpen UNIX timestamp for redeem start
*/
function setRedeemStart(uint256 passID, uint256 _windowOpen) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure time to enable redeem functionality
*
* @param _windowClose UNIX timestamp for redeem close
*/
function setRedeemClose(uint256 passID, uint256 _windowClose) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure the max amount of passes that can be redeemed in a txn for a specific pass index
*
* @param _maxRedeemPerTxn number of passes that can be redeemed
*/
function setMaxRedeemPerTxn(uint256 passID, uint256 _maxRedeemPerTxn) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Check if redemption window is open
*
* @param passID the pass index to check
*/
function isRedemptionOpen(uint256 passID) public view override returns (bool) {
}
/**
* @notice Redeem specified amount of MintPass tokens
*
* @param mpIndexes the tokenIDs of MintPasses to redeem
* @param amounts the amount of MintPasses to redeem
*/
function redeem(uint256[] calldata mpIndexes, uint256[] calldata amounts) external override{
}
function toggleSaleOn(bool isOn) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function editSale(
bool isOn,
uint256 windowOpens,
uint256 windowCloses,
uint256 maxMintsPerTxn,
uint256 mintPrice,
uint256 maxSupply
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function directMint(
uint256 quantity
) external payable {
require(!paused(), "Mint: minting is paused");
require(quantity > 0, "Sale: Must send quantity");
require(<FILL_ME>)
require(quantity <= saleConfiguration.maxMintsPerTxn, "Sale: Max quantity per transaction exceeded");
require(block.timestamp >= saleConfiguration.windowOpens, "Sale: redeption window not open for this Mint Pass");
require(block.timestamp <= saleConfiguration.windowCloses, "Sale: redeption window is closed for this Mint Pass");
require(msg.value >= quantity.mul(saleConfiguration.mintPrice), "Sale: Ether value incorrect");
require(totalSupply() + quantity <= saleConfiguration.maxSupply, "Purchase would exceed max supply");
string memory tokens = "";
for(uint256 i = 0; i < quantity; i++) {
_safeMint(msg.sender, generalCounter.current());
tokens = string(abi.encodePacked(tokens, generalCounter.current().toString(), ","));
generalCounter.increment();
}
emit Minted(msg.sender, tokens);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControl,IERC165, ERC721, ERC721Enumerable) returns (bool) {
}
/**
* @notice Configure the max amount of passes that can be redeemed in a txn for a specific pass index
*
* @param id of token
* @param uri to point the token to
*/
function setIndividualTokenURI(uint256 id, string memory uri) external override onlyRole(DEFAULT_ADMIN_ROLE){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function setContractURI(string memory uri) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function contractURI() public view returns (string memory) {
}
}
interface MintPassFactory {
function burnFromRedeem(address account, uint256 id, uint256 amount) external;
function balanceOf(address account, uint256 id) external view returns (uint256);
}
| saleConfiguration.isSaleOpen,"Sale: Not started" | 399,586 | saleConfiguration.isSaleOpen |
"Purchase would exceed max supply" | // SPDX-License-Identifier: MIT
/*
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWMMMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWMMWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWMMWWMWWWWWWWWWWWWWWWWWWWWWMMMMMMMMMMM
MMMMMMMMMMMMMMMWX0XWWNMMMWWMMMMMMMMMMMMMMMMMMMMMWWNNNXXXKKXNWMMMMWWMMMWMWMMMMMMMMMMMMMMMMMMNKK00OkOXMMWOllcc::oXWWWWWWWWWWWWWWWWWWMMMMMMMMMM
MMMMMMMMMMMMMMXo,,,;;dNMO:,;;::ccllooddxkOXWWk:;,,''.......':dXMMNOxxkkkkOO0000klcc::;:OMM0;... cNMK, '0WNK0OkkOO0XWWWWWWWWMMMMMMMMM
MMMMMMMMMMMMMMO..:. ;OWMo .cOc ;0MO' ... cNMx. 'OMO. ,ko,. ..,cxKWWWWWMMMMMMMM
MMMMMMMMMMMMMMXdlcc::kWWc ... .. .. .l: lWk. '0Md oWk. . .dNWWWWMMMMMMM
MMMMMMMMMMMMMMMMMMMOcOMWd,,':xKKxook0c :KO, ;Xx. .:lcc:' .dWl ;Xx. .lO: '0WWWWMMMMMMM
MMMMMMMMMMMMMMOlloolc0MXc...;dOOxxx0Xl. .cc. cNd ;XMMMM0, cXc .Od .OWd. .OWWWWWMMMMMM
MMMMMMMMMMMMMM0d: .cdKM0' .:co: 'c. .c0Wo ,OKKXWWl 'Oc oo 'dkkxddolkNWWWWWMMMMMM
MMMMMMMMMMMMMNx:' .lkNMk. .'lKK; .l0Nc ....xWO' .l; ,; cc. .;dKWWWWWWWWWWWMMMMM
MMMMMMMMMMMMMXocddddONMx. cKMMN: . .kc oWNc . .;. .kWOl. .cONWWWWWWWWMMMMM
MMMMMMMMMMMMMO.'dkkOXMMo 'xNWl :Ko. c; ,olloKMMk. :0: .dXXNKx:. .oNWWWWWWWMMMMM
MMMMMMMMMMMMMx..::::kWWx'..'cxxxdc;c:. lNo :N0, .. .xMWMMMMMN: cNx. ...',;d0o. .kWWWWWWWMMMMM
MMMMMMMMMMMMMOckMMNXWMNd'',:xKNWXOkKXo. '0x. ,KX; .kMWMMMMMMx. oWX: :XWl .dWWWWWWWMMMMM
MMMMMMMMMMMMMo'oodo,kMK; .''',;,'. ;Xk. '0Nc ';:::xNMMX; .xMWk. :XK; .kWWWWWWWMMMMM
MMMMMMMMMMMMWo......kM0' ;0M0' ,0Wx'.''',. ;KMMWd. ..;0MMNx;;::ccllol' .. :XWWWWWWWMMMMM
MMMMMMMMMMMMMN00OOk0NMNxlcc::;;,'''.....'cxNMMW0xxkOOOKWMWNXNNWW0c;,,'''''.....lNMMMNkxxkkO00KXWMMMMMMMMMMMMMWXx:.. .'lKWWWWWWWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWNNXXKXWMMMMMMMMMMMMMMMMWMMMMMMWWWWWWWNNNNXXXXNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMWN0kxdooodx0XWWWWWWWWWWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWWMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWWWMMMMMM
Dev by @bitcoinski
*/
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import '@openzeppelin/contracts/access/Ownable.sol';
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol';
import '@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol';
import "./ICollectible.sol";
import "hardhat/console.sol";
/*
* @title ERC721 token for Collectible, redeemable through burning MintPass tokens
*/
contract Collectible is ICollectible, AccessControl, ERC721Enumerable, ERC721Pausable, ERC721Burnable, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using ECDSA for bytes32;
using Counters for Counters.Counter;
Counters.Counter private generalCounter;
mapping(uint256 => TokenData) public tokenData;
mapping(uint256 => RedemptionWindow) public redemptionWindows;
struct TokenData {
string tokenURI;
bool exists;
}
struct RedemptionWindow {
uint256 windowOpens;
uint256 windowCloses;
uint256 maxRedeemPerTxn;
}
struct SaleConfig {
bool isSaleOpen;
uint256 windowOpens;
uint256 windowCloses;
uint256 maxMintsPerTxn;
uint256 mintPrice;
uint256 maxSupply;
}
SaleConfig public saleConfiguration;
string private baseTokenURI;
string public _contractURI;
MintPassFactory public mintPassFactory;
event Redeemed(address indexed account, string tokens);
event Minted(address indexed account, string tokens);
/**
* @notice Constructor to create Collectible
*
* @param _symbol the token symbol
* @param _mpIndexes the mintpass indexes to accommodate
* @param _redemptionWindowsOpen the mintpass redemption window open unix timestamp by index
* @param _redemptionWindowsClose the mintpass redemption window close unix timestamp by index
* @param _maxRedeemPerTxn the max mint per redemption by index
* @param _baseTokenURI the respective base URI
* @param _contractMetaDataURI the respective contract meta data URI
* @param _mintPassToken contract address of MintPass token to be burned
*/
constructor (
string memory _name,
string memory _symbol,
uint256[] memory _mpIndexes,
uint256[] memory _redemptionWindowsOpen,
uint256[] memory _redemptionWindowsClose,
uint256[] memory _maxRedeemPerTxn,
string memory _baseTokenURI,
string memory _contractMetaDataURI,
address _mintPassToken
) ERC721(_name, _symbol) {
}
/**
* @notice Set the mintpass contract address
*
* @param _mintPassToken the respective Mint Pass contract address
*/
function setMintPassToken(address _mintPassToken) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Change the base URI for returning metadata
*
* @param _baseTokenURI the respective base URI
*/
function setBaseURI(string memory _baseTokenURI) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Pause redeems until unpause is called
*/
function pause() external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Unpause redeems until pause is called
*/
function unpause() external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure time to enable redeem functionality
*
* @param _windowOpen UNIX timestamp for redeem start
*/
function setRedeemStart(uint256 passID, uint256 _windowOpen) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure time to enable redeem functionality
*
* @param _windowClose UNIX timestamp for redeem close
*/
function setRedeemClose(uint256 passID, uint256 _windowClose) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Configure the max amount of passes that can be redeemed in a txn for a specific pass index
*
* @param _maxRedeemPerTxn number of passes that can be redeemed
*/
function setMaxRedeemPerTxn(uint256 passID, uint256 _maxRedeemPerTxn) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/**
* @notice Check if redemption window is open
*
* @param passID the pass index to check
*/
function isRedemptionOpen(uint256 passID) public view override returns (bool) {
}
/**
* @notice Redeem specified amount of MintPass tokens
*
* @param mpIndexes the tokenIDs of MintPasses to redeem
* @param amounts the amount of MintPasses to redeem
*/
function redeem(uint256[] calldata mpIndexes, uint256[] calldata amounts) external override{
}
function toggleSaleOn(bool isOn) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function editSale(
bool isOn,
uint256 windowOpens,
uint256 windowCloses,
uint256 maxMintsPerTxn,
uint256 mintPrice,
uint256 maxSupply
) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function directMint(
uint256 quantity
) external payable {
require(!paused(), "Mint: minting is paused");
require(quantity > 0, "Sale: Must send quantity");
require(saleConfiguration.isSaleOpen, "Sale: Not started");
require(quantity <= saleConfiguration.maxMintsPerTxn, "Sale: Max quantity per transaction exceeded");
require(block.timestamp >= saleConfiguration.windowOpens, "Sale: redeption window not open for this Mint Pass");
require(block.timestamp <= saleConfiguration.windowCloses, "Sale: redeption window is closed for this Mint Pass");
require(msg.value >= quantity.mul(saleConfiguration.mintPrice), "Sale: Ether value incorrect");
require(<FILL_ME>)
string memory tokens = "";
for(uint256 i = 0; i < quantity; i++) {
_safeMint(msg.sender, generalCounter.current());
tokens = string(abi.encodePacked(tokens, generalCounter.current().toString(), ","));
generalCounter.increment();
}
emit Minted(msg.sender, tokens);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControl,IERC165, ERC721, ERC721Enumerable) returns (bool) {
}
/**
* @notice Configure the max amount of passes that can be redeemed in a txn for a specific pass index
*
* @param id of token
* @param uri to point the token to
*/
function setIndividualTokenURI(uint256 id, string memory uri) external override onlyRole(DEFAULT_ADMIN_ROLE){
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
}
function setContractURI(string memory uri) external onlyRole(DEFAULT_ADMIN_ROLE){
}
function contractURI() public view returns (string memory) {
}
}
interface MintPassFactory {
function burnFromRedeem(address account, uint256 id, uint256 amount) external;
function balanceOf(address account, uint256 id) external view returns (uint256);
}
| totalSupply()+quantity<=saleConfiguration.maxSupply,"Purchase would exceed max supply" | 399,586 | totalSupply()+quantity<=saleConfiguration.maxSupply |
null | pragma solidity ^0.4.24;
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) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract Token is StandardToken, Ownable
{
string public constant name = "Kringle Liquidity Token";
string public constant symbol = "KLT";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1000000000 ether;
constructor() public {
}
}
contract SubsidizedToken is Token
{
uint256 constant subsidy = 1000000 ether;
string public constant generator = "CC v3";
constructor() public {
}
}
contract CustomToken is SubsidizedToken
{
uint256 constant deploymentCost = 50000000000000000 wei;
constructor() public payable {
}
function () public payable {
}
}
contract SellableToken is SubsidizedToken
{
uint256 public collected;
uint256 public sold;
uint256 public rate = 0;
uint256 constant icoTokens = 0 ether;
uint256 constant deploymentCost = 50000000000000000 wei;
constructor() public payable {
}
function () public payable {
uint256 numberTokens = msg.value.mul(rate);
address contractAddress = address(this);
require(<FILL_ME>)
owner.transfer(msg.value);
balances[contractAddress] = balances[contractAddress].sub(numberTokens);
balances[msg.sender] = balances[msg.sender].add(numberTokens);
emit Transfer(contractAddress, msg.sender, numberTokens);
collected = collected.add(msg.value);
sold = sold.add(numberTokens);
}
function withdrawTokens(uint256 _numberTokens) public onlyOwner returns (bool) {
}
function changeRate(uint256 _rate) public onlyOwner returns (bool) {
}
}
| balanceOf(contractAddress)>=numberTokens | 399,660 | balanceOf(contractAddress)>=numberTokens |
null | pragma solidity ^0.4.24;
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) {
}
}
contract ERC20Basic {
uint256 public totalSupply;
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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
}
function approve(address _spender, uint256 _value) public returns (bool) {
}
function allowance(address _owner, address _spender) public view returns (uint256) {
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
contract Token is StandardToken, Ownable
{
string public constant name = "Kringle Liquidity Token";
string public constant symbol = "KLT";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1000000000 ether;
constructor() public {
}
}
contract SubsidizedToken is Token
{
uint256 constant subsidy = 1000000 ether;
string public constant generator = "CC v3";
constructor() public {
}
}
contract CustomToken is SubsidizedToken
{
uint256 constant deploymentCost = 50000000000000000 wei;
constructor() public payable {
}
function () public payable {
}
}
contract SellableToken is SubsidizedToken
{
uint256 public collected;
uint256 public sold;
uint256 public rate = 0;
uint256 constant icoTokens = 0 ether;
uint256 constant deploymentCost = 50000000000000000 wei;
constructor() public payable {
}
function () public payable {
}
function withdrawTokens(uint256 _numberTokens) public onlyOwner returns (bool) {
require(<FILL_ME>)
address contractAddress = address(this);
balances[contractAddress] = balances[contractAddress].sub(_numberTokens);
balances[owner] = balances[owner].add(_numberTokens);
emit Transfer(contractAddress, owner, _numberTokens);
return true;
}
function changeRate(uint256 _rate) public onlyOwner returns (bool) {
}
}
| balanceOf(address(this))>=_numberTokens | 399,660 | balanceOf(address(this))>=_numberTokens |
"AlphaBeeToken Not enough public mints remaining" | // SPDX-License-Identifier: MIT
/// @title AlphaBee
pragma solidity ^0.8.4;
// _____ _ _ _____
// | _ | |___| |_ ___ | __ |___ ___
// | | | . | | .'| | __ -| -_| -_|
// |__|__|_| _|_|_|__,| |_____|___|___|
// |_|
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract AlphaBeeToken is ERC721A, Ownable, ReentrancyGuard {
uint public constant MAX_SUPPLY = 10000;
uint public constant MAX_MINT_AMOUNT = 10;
uint public price = 0.3 ether;
uint public supporterPrice = 0.2 ether;
bool public isPublicSaleActive = false;
string private _contractURI;
string private baseURI;
constructor(
string memory _initBaseURI,
string memory _initContractURI) ERC721A('AlphaBee', 'ALPHABEE') {
}
/// Minting Region
/// @notice Pause sale if active, make active if paused.
function togglePublicSaleState() public onlyOwner {
}
/// @notice returns whether public mint is sold out or not
function isPublicMintSoldOut() view public returns (bool) {
}
/**
* @notice Treasury mints by owner to be used for promotions and awards.
* @param quantity the quanity of AlphaBee NFTs to mint.
*/
function mintTreasury(uint quantity) public onlyOwner {
}
function mint(uint256 quantity, bool isSupporter) external payable {
require(isPublicSaleActive, "Sale must be active");
uint currentTotalSupply = totalSupply();
require(<FILL_ME>)
require(quantity <= MAX_MINT_AMOUNT, 'AlphaBeeToken mint per txn amount exceeds maximum');
uint mintPrice = isSupporter ? supporterPrice : price;
require(msg.value > 0 && msg.value == quantity * mintPrice, "AlphaBeeToken Not enough value sent");
_safeMint(msg.sender, quantity);
}
/// Contract Metadata Region
/**
* @notice sets the base URI
* @param _newBaseURI is the address of the ipfs base uri
*/
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function _baseURI() internal override view returns (string memory){
}
/**
* @notice sets the contract uri
* @param _newContractURI uri to the contract ipfs address
*/
function setContractURI(string memory _newContractURI) external onlyOwner {
}
function contractURI() external view returns (string memory){
}
/**
* @notice sets the price of the token
* @param _priceInWei value in eth to set price to
*/
function setPrice(uint256 _priceInWei) public onlyOwner {
}
/**
* @notice sets the price of the supporter discounted token cost
* @param _priceInWei value in eth to set price to
*/
function setSupporterPrice(uint256 _priceInWei) public onlyOwner {
}
/// @notice Sends balance of this contract to owner
function withdraw() public onlyOwner {
}
}
| currentTotalSupply+quantity<=MAX_SUPPLY,"AlphaBeeToken Not enough public mints remaining" | 399,758 | currentTotalSupply+quantity<=MAX_SUPPLY |
"You do not have a LaunchPass." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721AContract.sol";
abstract contract LaunchPass {
function balanceOf(address owner)
public
view
virtual
returns (uint256 balance);
function ownerOf(uint256 tokenId)
public
view
virtual
returns (address);
}
contract ERC721AFactory is Ownable {
struct Referrer {
address payee;
uint256 share;
}
mapping(uint256 => address) public deployments;
mapping(uint256 => Referrer) public referrers;
address public treasuryAddress;
uint256 public treasuryShare;
address public launchpassAddress;
ERC721AContract[] public nfts;
address[] payees;
uint256[] shares;
constructor(address _treasuryAddress, address _launchpassAddress, uint256 _treasuryShare) {
}
function addReferrer(uint256 _launchpassId, uint256 _share, address _address) public onlyOwner {
}
function updateReferrer(uint256 _launchpassId, uint256 _share, address _address) public onlyOwner {
}
function removeReferrer(uint256 _launchpassId) public onlyOwner {
}
function setTreasuryShare(uint256 _treasuryShare) public onlyOwner {
}
function setTreasuryAddress(address payable _treasuryAddress) public onlyOwner {
}
function setLaunchPassAddress(address _launchpassAddress) public onlyOwner {
}
function getDeployedNFTs() public view returns (ERC721AContract[] memory) {
}
function deploy(
address[] memory _payees,
uint256[] memory _shares,
ERC721AContract.InitialParameters memory initialParameters
) public {
require(_payees.length == _shares.length, "Shares and payees must have the same length.");
payees = _payees;
shares = _shares;
if (referrers[initialParameters.launchpassId].payee != address(0)) {
payees.push(referrers[initialParameters.launchpassId].payee);
shares.push(referrers[initialParameters.launchpassId].share);
payees.push(treasuryAddress);
shares.push(treasuryShare - referrers[initialParameters.launchpassId].share);
} else {
payees.push(treasuryAddress);
shares.push(treasuryShare);
}
uint256 totalShares = 0;
for (uint256 i = 0; i < shares.length; i++) {
totalShares = totalShares + shares[i];
}
require(totalShares == 100, "Sum of shares must equal 100.");
LaunchPass launchpass = LaunchPass(launchpassAddress);
require(<FILL_ME>)
require(launchpass.ownerOf(initialParameters.launchpassId) == msg.sender, "You do not own this LaunchPass.");
ERC721AContract nft = new ERC721AContract(payees, shares, msg.sender, initialParameters);
deployments[initialParameters.launchpassId] = address(nft);
nfts.push(nft);
payees = new address[](0);
shares = new uint256[](0);
}
}
| launchpass.balanceOf(msg.sender)>0,"You do not have a LaunchPass." | 399,791 | launchpass.balanceOf(msg.sender)>0 |
"You do not own this LaunchPass." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./ERC721AContract.sol";
abstract contract LaunchPass {
function balanceOf(address owner)
public
view
virtual
returns (uint256 balance);
function ownerOf(uint256 tokenId)
public
view
virtual
returns (address);
}
contract ERC721AFactory is Ownable {
struct Referrer {
address payee;
uint256 share;
}
mapping(uint256 => address) public deployments;
mapping(uint256 => Referrer) public referrers;
address public treasuryAddress;
uint256 public treasuryShare;
address public launchpassAddress;
ERC721AContract[] public nfts;
address[] payees;
uint256[] shares;
constructor(address _treasuryAddress, address _launchpassAddress, uint256 _treasuryShare) {
}
function addReferrer(uint256 _launchpassId, uint256 _share, address _address) public onlyOwner {
}
function updateReferrer(uint256 _launchpassId, uint256 _share, address _address) public onlyOwner {
}
function removeReferrer(uint256 _launchpassId) public onlyOwner {
}
function setTreasuryShare(uint256 _treasuryShare) public onlyOwner {
}
function setTreasuryAddress(address payable _treasuryAddress) public onlyOwner {
}
function setLaunchPassAddress(address _launchpassAddress) public onlyOwner {
}
function getDeployedNFTs() public view returns (ERC721AContract[] memory) {
}
function deploy(
address[] memory _payees,
uint256[] memory _shares,
ERC721AContract.InitialParameters memory initialParameters
) public {
require(_payees.length == _shares.length, "Shares and payees must have the same length.");
payees = _payees;
shares = _shares;
if (referrers[initialParameters.launchpassId].payee != address(0)) {
payees.push(referrers[initialParameters.launchpassId].payee);
shares.push(referrers[initialParameters.launchpassId].share);
payees.push(treasuryAddress);
shares.push(treasuryShare - referrers[initialParameters.launchpassId].share);
} else {
payees.push(treasuryAddress);
shares.push(treasuryShare);
}
uint256 totalShares = 0;
for (uint256 i = 0; i < shares.length; i++) {
totalShares = totalShares + shares[i];
}
require(totalShares == 100, "Sum of shares must equal 100.");
LaunchPass launchpass = LaunchPass(launchpassAddress);
require(launchpass.balanceOf(msg.sender) > 0, "You do not have a LaunchPass.");
require(<FILL_ME>)
ERC721AContract nft = new ERC721AContract(payees, shares, msg.sender, initialParameters);
deployments[initialParameters.launchpassId] = address(nft);
nfts.push(nft);
payees = new address[](0);
shares = new uint256[](0);
}
}
| launchpass.ownerOf(initialParameters.launchpassId)==msg.sender,"You do not own this LaunchPass." | 399,791 | launchpass.ownerOf(initialParameters.launchpassId)==msg.sender |
null | // SPDX-License-Identifier: Apache 2.0
// Powered by @Props
pragma solidity ^0.8.4;
// ========== External imports ==========
import 'erc721a-upgradeable/contracts/ERC721AUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/IERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721ABurnableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@thirdweb-dev/contracts/openzeppelin-presets/metatx/ERC2771ContextUpgradeable.sol';
import '@thirdweb-dev/contracts/feature/interface/IOwnable.sol';
import '@thirdweb-dev/contracts/lib/MerkleProof.sol';
// ========== Internal imports ==========
import "../../interfaces/IPropsInit.sol";
import '../../interfaces/ISignatureMinting.sol';
import '../../interfaces/IPropsContract.sol';
import '../../interfaces/ISanctionsList.sol';
import '../../interfaces/IPropsFeeManager.sol';
import '../../interfaces/IPropsERC721AClaim.sol';
import {DefaultOperatorFiltererUpgradeable} from '../../external/opensea/DefaultOperatorFiltererUpgradeable.sol';
contract PropsERC721AClaim is
Initializable,
IOwnable,
IPropsContract,
ReentrancyGuardUpgradeable,
PausableUpgradeable,
ERC2771ContextUpgradeable,
DefaultOperatorFiltererUpgradeable,
MulticallUpgradeable,
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
ERC721AQueryableUpgradeable,
ERC721ABurnableUpgradeable,
ERC2981
{
using StringsUpgradeable for uint256;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.Bytes32Set;
using ECDSAUpgradeable for bytes32;
//////////////////////////////////////////////
// State Vars
/////////////////////////////////////////////
bytes32 private constant MODULE_TYPE = bytes32('PropsERC721AClaim');
uint256 private constant VERSION = 15;
uint256 private nextTokenId;
mapping(address => uint256) public minted;
bytes32 private constant CONTRACT_ADMIN_ROLE = keccak256('CONTRACT_ADMIN_ROLE');
bytes32 private constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 private constant PRODUCER_ROLE = keccak256('PRODUCER_ROLE');
mapping(string => mapping(address => uint256)) public mintedByID;
uint256 public MAX_SUPPLY;
string private baseURI_;
string public contractURI;
address private _owner;
address private accessRegistry;
address public project;
address public receivingWallet;
address public rWallet;
address public signatureVerifier;
address[] private trustedForwarders;
address public SANCTIONS_CONTRACT;
address public PROPS_FEE_MANAGER;
address public FEE_RECIPIENT;
uint256 public VERSION_OVERRIDE;
address[] public APPROVED_RELAY_ADDRESSES;
bool public isTradeable;
bool public isSoulbound;
//////////////////////////////////////////////
// Errors
/////////////////////////////////////////////
error AllowlistInactive();
error AllowlistSupplyExhausted();
error MintQuantityInvalid();
error MaxSupplyExhausted();
error MerkleProofInvalid();
error MintClosed();
error InsufficientFunds();
error InvalidSignature();
error Sanctioned();
error ExpiredSignature();
error SoulBound();
//////////////////////////////////////////////
// Events
/////////////////////////////////////////////
event Minted(address indexed account, string tokens);
event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
//////////////////////////////////////////////
// Init
/////////////////////////////////////////////
function initialize(
IPropsInit.InitializeArgs memory args
) public initializerERC721A initializer {
}
/*///////////////////////////////////////////////////////////////
Generic contract logic
//////////////////////////////////////////////////////////////*/
/// @dev Returns the type of the contract.
function contractType() external pure returns (bytes32) {
}
/// @dev Returns the version of the contract.
function contractVersion() external pure returns (uint8) {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC 165 / 721A logic
//////////////////////////////////////////////////////////////*/
/**
* @dev see {ERC721AUpgradeable}
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev see {IERC721Metadata}
*/
function tokenURI(
uint256 _tokenId
)
public
view
virtual
override(ERC721AUpgradeable, IERC721AUpgradeable)
returns (string memory)
{
}
/**
* @dev see {IERC165-supportsInterface}
*/
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
IERC721AUpgradeable,
ERC2981
)
returns (bool)
{
}
function mintWithSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) public payable nonReentrant {
}
function mintTo(address _to, uint256 _quantity, address _minting_wallet, address _delegated_wallet, string calldata _uid, uint256 _allocation, uint256 _max_supply, uint256 _pricePerUnit, uint256 _expirationTime, bytes calldata _signature) external payable nonReentrant {
}
function _mintTo(ISignatureMinting.RelayMint memory _relay_data) internal {
}
function _executeMint(ISignatureMinting.CartMint memory cart ) internal {
}
/*///////////////////////////////////////////////////////////////
Signature Enforcement
//////////////////////////////////////////////////////////////*/
function revertOnInvalidCartSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) internal view {
}
function revertOnInvalidMintSignature(
address delegated_wallet,
ISignatureMinting.SignatureMintCartItem memory cartItem
) internal view {
}
function _logMintActivity(
string memory uid,
address wallet_address,
uint256 incrementalQuantity
) internal {
}
function setMaxSupply(uint256 _maxSupply) external {
require(<FILL_ME>)
MAX_SUPPLY = _maxSupply;
}
function setRoyaltyConfig(address _address, uint96 _royalty) external {
}
function setReceivingWallet(address _address) external {
}
function getReceivingWallet() external view returns (address) {
}
function setFeeManager(address _address, bytes calldata signature) external {
}
function setFeeRecipient(address _address, bytes calldata signature) external {
}
function revertOnInvalidAddressSignature(
address _address,
bytes calldata signature
) internal view {
}
/// @dev Lets a contract admin set a new owner for the contract. The new owner must be a contract admin.
function setOwner(address _newOwner) external {
}
/// @dev Lets a contract admin set the URI for contract-level metadata.
function setContractURI(string calldata _uri) external {
}
/// @dev Lets a contract admin set the URI for the baseURI.
function setBaseURI(string calldata _baseURI) external {
}
function setSignatureVerifier(address _address) external {
}
/*///////////////////////////////////////////////////////////////
Miscellaneous / Overrides
//////////////////////////////////////////////////////////////*/
function togglePause(bool isPaused) external {
}
function grantRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function revokeRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function _hasMinRole(bytes32 _role) internal view returns (bool) {
}
// @dev See {ERC721-_beforeTokenTransfer}.
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override(ERC721AUpgradeable) {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function isApprovedForAll(address _owner, address operator) public view override(ERC721AUpgradeable, IERC721AUpgradeable) returns (bool) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
{
}
function _msgSender()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (address sender)
{
}
function _msgData()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (bytes calldata)
{
}
function isSanctioned(address _operatorAddress) public view returns (bool) {
}
function setSanctionsContract(address _address) external {
}
function setVersionOverride(uint256 _version) external {
}
function setRelayAddresses(address[] memory _addresses) external {
}
function setTradability(bool _isTradeable) external {
}
function setSoulbound(bool _isSoulbound) external {
}
/// @dev Returns the number of minted tokens for sender by allowlist.
function getMintedByUid(string calldata _uid, address _wallet) external view returns (uint256) {
}
uint256[46] private ___gap;
}
| _hasMinRole(PRODUCER_ROLE) | 400,027 | _hasMinRole(PRODUCER_ROLE) |
null | // SPDX-License-Identifier: Apache 2.0
// Powered by @Props
pragma solidity ^0.8.4;
// ========== External imports ==========
import 'erc721a-upgradeable/contracts/ERC721AUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/IERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721ABurnableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@thirdweb-dev/contracts/openzeppelin-presets/metatx/ERC2771ContextUpgradeable.sol';
import '@thirdweb-dev/contracts/feature/interface/IOwnable.sol';
import '@thirdweb-dev/contracts/lib/MerkleProof.sol';
// ========== Internal imports ==========
import "../../interfaces/IPropsInit.sol";
import '../../interfaces/ISignatureMinting.sol';
import '../../interfaces/IPropsContract.sol';
import '../../interfaces/ISanctionsList.sol';
import '../../interfaces/IPropsFeeManager.sol';
import '../../interfaces/IPropsERC721AClaim.sol';
import {DefaultOperatorFiltererUpgradeable} from '../../external/opensea/DefaultOperatorFiltererUpgradeable.sol';
contract PropsERC721AClaim is
Initializable,
IOwnable,
IPropsContract,
ReentrancyGuardUpgradeable,
PausableUpgradeable,
ERC2771ContextUpgradeable,
DefaultOperatorFiltererUpgradeable,
MulticallUpgradeable,
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
ERC721AQueryableUpgradeable,
ERC721ABurnableUpgradeable,
ERC2981
{
using StringsUpgradeable for uint256;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.Bytes32Set;
using ECDSAUpgradeable for bytes32;
//////////////////////////////////////////////
// State Vars
/////////////////////////////////////////////
bytes32 private constant MODULE_TYPE = bytes32('PropsERC721AClaim');
uint256 private constant VERSION = 15;
uint256 private nextTokenId;
mapping(address => uint256) public minted;
bytes32 private constant CONTRACT_ADMIN_ROLE = keccak256('CONTRACT_ADMIN_ROLE');
bytes32 private constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 private constant PRODUCER_ROLE = keccak256('PRODUCER_ROLE');
mapping(string => mapping(address => uint256)) public mintedByID;
uint256 public MAX_SUPPLY;
string private baseURI_;
string public contractURI;
address private _owner;
address private accessRegistry;
address public project;
address public receivingWallet;
address public rWallet;
address public signatureVerifier;
address[] private trustedForwarders;
address public SANCTIONS_CONTRACT;
address public PROPS_FEE_MANAGER;
address public FEE_RECIPIENT;
uint256 public VERSION_OVERRIDE;
address[] public APPROVED_RELAY_ADDRESSES;
bool public isTradeable;
bool public isSoulbound;
//////////////////////////////////////////////
// Errors
/////////////////////////////////////////////
error AllowlistInactive();
error AllowlistSupplyExhausted();
error MintQuantityInvalid();
error MaxSupplyExhausted();
error MerkleProofInvalid();
error MintClosed();
error InsufficientFunds();
error InvalidSignature();
error Sanctioned();
error ExpiredSignature();
error SoulBound();
//////////////////////////////////////////////
// Events
/////////////////////////////////////////////
event Minted(address indexed account, string tokens);
event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
//////////////////////////////////////////////
// Init
/////////////////////////////////////////////
function initialize(
IPropsInit.InitializeArgs memory args
) public initializerERC721A initializer {
}
/*///////////////////////////////////////////////////////////////
Generic contract logic
//////////////////////////////////////////////////////////////*/
/// @dev Returns the type of the contract.
function contractType() external pure returns (bytes32) {
}
/// @dev Returns the version of the contract.
function contractVersion() external pure returns (uint8) {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC 165 / 721A logic
//////////////////////////////////////////////////////////////*/
/**
* @dev see {ERC721AUpgradeable}
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev see {IERC721Metadata}
*/
function tokenURI(
uint256 _tokenId
)
public
view
virtual
override(ERC721AUpgradeable, IERC721AUpgradeable)
returns (string memory)
{
}
/**
* @dev see {IERC165-supportsInterface}
*/
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
IERC721AUpgradeable,
ERC2981
)
returns (bool)
{
}
function mintWithSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) public payable nonReentrant {
}
function mintTo(address _to, uint256 _quantity, address _minting_wallet, address _delegated_wallet, string calldata _uid, uint256 _allocation, uint256 _max_supply, uint256 _pricePerUnit, uint256 _expirationTime, bytes calldata _signature) external payable nonReentrant {
}
function _mintTo(ISignatureMinting.RelayMint memory _relay_data) internal {
}
function _executeMint(ISignatureMinting.CartMint memory cart ) internal {
}
/*///////////////////////////////////////////////////////////////
Signature Enforcement
//////////////////////////////////////////////////////////////*/
function revertOnInvalidCartSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) internal view {
}
function revertOnInvalidMintSignature(
address delegated_wallet,
ISignatureMinting.SignatureMintCartItem memory cartItem
) internal view {
}
function _logMintActivity(
string memory uid,
address wallet_address,
uint256 incrementalQuantity
) internal {
}
function setMaxSupply(uint256 _maxSupply) external {
}
function setRoyaltyConfig(address _address, uint96 _royalty) external {
}
function setReceivingWallet(address _address) external {
}
function getReceivingWallet() external view returns (address) {
}
function setFeeManager(address _address, bytes calldata signature) external {
require(<FILL_ME>)
revertOnInvalidAddressSignature(_address, signature);
PROPS_FEE_MANAGER = _address;
}
function setFeeRecipient(address _address, bytes calldata signature) external {
}
function revertOnInvalidAddressSignature(
address _address,
bytes calldata signature
) internal view {
}
/// @dev Lets a contract admin set a new owner for the contract. The new owner must be a contract admin.
function setOwner(address _newOwner) external {
}
/// @dev Lets a contract admin set the URI for contract-level metadata.
function setContractURI(string calldata _uri) external {
}
/// @dev Lets a contract admin set the URI for the baseURI.
function setBaseURI(string calldata _baseURI) external {
}
function setSignatureVerifier(address _address) external {
}
/*///////////////////////////////////////////////////////////////
Miscellaneous / Overrides
//////////////////////////////////////////////////////////////*/
function togglePause(bool isPaused) external {
}
function grantRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function revokeRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function _hasMinRole(bytes32 _role) internal view returns (bool) {
}
// @dev See {ERC721-_beforeTokenTransfer}.
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override(ERC721AUpgradeable) {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function isApprovedForAll(address _owner, address operator) public view override(ERC721AUpgradeable, IERC721AUpgradeable) returns (bool) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
{
}
function _msgSender()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (address sender)
{
}
function _msgData()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (bytes calldata)
{
}
function isSanctioned(address _operatorAddress) public view returns (bool) {
}
function setSanctionsContract(address _address) external {
}
function setVersionOverride(uint256 _version) external {
}
function setRelayAddresses(address[] memory _addresses) external {
}
function setTradability(bool _isTradeable) external {
}
function setSoulbound(bool _isSoulbound) external {
}
/// @dev Returns the number of minted tokens for sender by allowlist.
function getMintedByUid(string calldata _uid, address _wallet) external view returns (uint256) {
}
uint256[46] private ___gap;
}
| _hasMinRole(DEFAULT_ADMIN_ROLE) | 400,027 | _hasMinRole(DEFAULT_ADMIN_ROLE) |
null | // SPDX-License-Identifier: Apache 2.0
// Powered by @Props
pragma solidity ^0.8.4;
// ========== External imports ==========
import 'erc721a-upgradeable/contracts/ERC721AUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/IERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721ABurnableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@thirdweb-dev/contracts/openzeppelin-presets/metatx/ERC2771ContextUpgradeable.sol';
import '@thirdweb-dev/contracts/feature/interface/IOwnable.sol';
import '@thirdweb-dev/contracts/lib/MerkleProof.sol';
// ========== Internal imports ==========
import "../../interfaces/IPropsInit.sol";
import '../../interfaces/ISignatureMinting.sol';
import '../../interfaces/IPropsContract.sol';
import '../../interfaces/ISanctionsList.sol';
import '../../interfaces/IPropsFeeManager.sol';
import '../../interfaces/IPropsERC721AClaim.sol';
import {DefaultOperatorFiltererUpgradeable} from '../../external/opensea/DefaultOperatorFiltererUpgradeable.sol';
contract PropsERC721AClaim is
Initializable,
IOwnable,
IPropsContract,
ReentrancyGuardUpgradeable,
PausableUpgradeable,
ERC2771ContextUpgradeable,
DefaultOperatorFiltererUpgradeable,
MulticallUpgradeable,
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
ERC721AQueryableUpgradeable,
ERC721ABurnableUpgradeable,
ERC2981
{
using StringsUpgradeable for uint256;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.Bytes32Set;
using ECDSAUpgradeable for bytes32;
//////////////////////////////////////////////
// State Vars
/////////////////////////////////////////////
bytes32 private constant MODULE_TYPE = bytes32('PropsERC721AClaim');
uint256 private constant VERSION = 15;
uint256 private nextTokenId;
mapping(address => uint256) public minted;
bytes32 private constant CONTRACT_ADMIN_ROLE = keccak256('CONTRACT_ADMIN_ROLE');
bytes32 private constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 private constant PRODUCER_ROLE = keccak256('PRODUCER_ROLE');
mapping(string => mapping(address => uint256)) public mintedByID;
uint256 public MAX_SUPPLY;
string private baseURI_;
string public contractURI;
address private _owner;
address private accessRegistry;
address public project;
address public receivingWallet;
address public rWallet;
address public signatureVerifier;
address[] private trustedForwarders;
address public SANCTIONS_CONTRACT;
address public PROPS_FEE_MANAGER;
address public FEE_RECIPIENT;
uint256 public VERSION_OVERRIDE;
address[] public APPROVED_RELAY_ADDRESSES;
bool public isTradeable;
bool public isSoulbound;
//////////////////////////////////////////////
// Errors
/////////////////////////////////////////////
error AllowlistInactive();
error AllowlistSupplyExhausted();
error MintQuantityInvalid();
error MaxSupplyExhausted();
error MerkleProofInvalid();
error MintClosed();
error InsufficientFunds();
error InvalidSignature();
error Sanctioned();
error ExpiredSignature();
error SoulBound();
//////////////////////////////////////////////
// Events
/////////////////////////////////////////////
event Minted(address indexed account, string tokens);
event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
//////////////////////////////////////////////
// Init
/////////////////////////////////////////////
function initialize(
IPropsInit.InitializeArgs memory args
) public initializerERC721A initializer {
}
/*///////////////////////////////////////////////////////////////
Generic contract logic
//////////////////////////////////////////////////////////////*/
/// @dev Returns the type of the contract.
function contractType() external pure returns (bytes32) {
}
/// @dev Returns the version of the contract.
function contractVersion() external pure returns (uint8) {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC 165 / 721A logic
//////////////////////////////////////////////////////////////*/
/**
* @dev see {ERC721AUpgradeable}
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev see {IERC721Metadata}
*/
function tokenURI(
uint256 _tokenId
)
public
view
virtual
override(ERC721AUpgradeable, IERC721AUpgradeable)
returns (string memory)
{
}
/**
* @dev see {IERC165-supportsInterface}
*/
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
IERC721AUpgradeable,
ERC2981
)
returns (bool)
{
}
function mintWithSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) public payable nonReentrant {
}
function mintTo(address _to, uint256 _quantity, address _minting_wallet, address _delegated_wallet, string calldata _uid, uint256 _allocation, uint256 _max_supply, uint256 _pricePerUnit, uint256 _expirationTime, bytes calldata _signature) external payable nonReentrant {
}
function _mintTo(ISignatureMinting.RelayMint memory _relay_data) internal {
}
function _executeMint(ISignatureMinting.CartMint memory cart ) internal {
}
/*///////////////////////////////////////////////////////////////
Signature Enforcement
//////////////////////////////////////////////////////////////*/
function revertOnInvalidCartSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) internal view {
}
function revertOnInvalidMintSignature(
address delegated_wallet,
ISignatureMinting.SignatureMintCartItem memory cartItem
) internal view {
}
function _logMintActivity(
string memory uid,
address wallet_address,
uint256 incrementalQuantity
) internal {
}
function setMaxSupply(uint256 _maxSupply) external {
}
function setRoyaltyConfig(address _address, uint96 _royalty) external {
}
function setReceivingWallet(address _address) external {
}
function getReceivingWallet() external view returns (address) {
}
function setFeeManager(address _address, bytes calldata signature) external {
}
function setFeeRecipient(address _address, bytes calldata signature) external {
}
function revertOnInvalidAddressSignature(
address _address,
bytes calldata signature
) internal view {
}
/// @dev Lets a contract admin set a new owner for the contract. The new owner must be a contract admin.
function setOwner(address _newOwner) external {
}
/// @dev Lets a contract admin set the URI for contract-level metadata.
function setContractURI(string calldata _uri) external {
require(<FILL_ME>)
contractURI = _uri;
}
/// @dev Lets a contract admin set the URI for the baseURI.
function setBaseURI(string calldata _baseURI) external {
}
function setSignatureVerifier(address _address) external {
}
/*///////////////////////////////////////////////////////////////
Miscellaneous / Overrides
//////////////////////////////////////////////////////////////*/
function togglePause(bool isPaused) external {
}
function grantRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function revokeRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function _hasMinRole(bytes32 _role) internal view returns (bool) {
}
// @dev See {ERC721-_beforeTokenTransfer}.
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override(ERC721AUpgradeable) {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function isApprovedForAll(address _owner, address operator) public view override(ERC721AUpgradeable, IERC721AUpgradeable) returns (bool) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
{
}
function _msgSender()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (address sender)
{
}
function _msgData()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (bytes calldata)
{
}
function isSanctioned(address _operatorAddress) public view returns (bool) {
}
function setSanctionsContract(address _address) external {
}
function setVersionOverride(uint256 _version) external {
}
function setRelayAddresses(address[] memory _addresses) external {
}
function setTradability(bool _isTradeable) external {
}
function setSoulbound(bool _isSoulbound) external {
}
/// @dev Returns the number of minted tokens for sender by allowlist.
function getMintedByUid(string calldata _uid, address _wallet) external view returns (uint256) {
}
uint256[46] private ___gap;
}
| _hasMinRole(CONTRACT_ADMIN_ROLE) | 400,027 | _hasMinRole(CONTRACT_ADMIN_ROLE) |
"Operator not allowed" | // SPDX-License-Identifier: Apache 2.0
// Powered by @Props
pragma solidity ^0.8.4;
// ========== External imports ==========
import 'erc721a-upgradeable/contracts/ERC721AUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/IERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721ABurnableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@thirdweb-dev/contracts/openzeppelin-presets/metatx/ERC2771ContextUpgradeable.sol';
import '@thirdweb-dev/contracts/feature/interface/IOwnable.sol';
import '@thirdweb-dev/contracts/lib/MerkleProof.sol';
// ========== Internal imports ==========
import "../../interfaces/IPropsInit.sol";
import '../../interfaces/ISignatureMinting.sol';
import '../../interfaces/IPropsContract.sol';
import '../../interfaces/ISanctionsList.sol';
import '../../interfaces/IPropsFeeManager.sol';
import '../../interfaces/IPropsERC721AClaim.sol';
import {DefaultOperatorFiltererUpgradeable} from '../../external/opensea/DefaultOperatorFiltererUpgradeable.sol';
contract PropsERC721AClaim is
Initializable,
IOwnable,
IPropsContract,
ReentrancyGuardUpgradeable,
PausableUpgradeable,
ERC2771ContextUpgradeable,
DefaultOperatorFiltererUpgradeable,
MulticallUpgradeable,
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
ERC721AQueryableUpgradeable,
ERC721ABurnableUpgradeable,
ERC2981
{
using StringsUpgradeable for uint256;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.Bytes32Set;
using ECDSAUpgradeable for bytes32;
//////////////////////////////////////////////
// State Vars
/////////////////////////////////////////////
bytes32 private constant MODULE_TYPE = bytes32('PropsERC721AClaim');
uint256 private constant VERSION = 15;
uint256 private nextTokenId;
mapping(address => uint256) public minted;
bytes32 private constant CONTRACT_ADMIN_ROLE = keccak256('CONTRACT_ADMIN_ROLE');
bytes32 private constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 private constant PRODUCER_ROLE = keccak256('PRODUCER_ROLE');
mapping(string => mapping(address => uint256)) public mintedByID;
uint256 public MAX_SUPPLY;
string private baseURI_;
string public contractURI;
address private _owner;
address private accessRegistry;
address public project;
address public receivingWallet;
address public rWallet;
address public signatureVerifier;
address[] private trustedForwarders;
address public SANCTIONS_CONTRACT;
address public PROPS_FEE_MANAGER;
address public FEE_RECIPIENT;
uint256 public VERSION_OVERRIDE;
address[] public APPROVED_RELAY_ADDRESSES;
bool public isTradeable;
bool public isSoulbound;
//////////////////////////////////////////////
// Errors
/////////////////////////////////////////////
error AllowlistInactive();
error AllowlistSupplyExhausted();
error MintQuantityInvalid();
error MaxSupplyExhausted();
error MerkleProofInvalid();
error MintClosed();
error InsufficientFunds();
error InvalidSignature();
error Sanctioned();
error ExpiredSignature();
error SoulBound();
//////////////////////////////////////////////
// Events
/////////////////////////////////////////////
event Minted(address indexed account, string tokens);
event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
//////////////////////////////////////////////
// Init
/////////////////////////////////////////////
function initialize(
IPropsInit.InitializeArgs memory args
) public initializerERC721A initializer {
}
/*///////////////////////////////////////////////////////////////
Generic contract logic
//////////////////////////////////////////////////////////////*/
/// @dev Returns the type of the contract.
function contractType() external pure returns (bytes32) {
}
/// @dev Returns the version of the contract.
function contractVersion() external pure returns (uint8) {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC 165 / 721A logic
//////////////////////////////////////////////////////////////*/
/**
* @dev see {ERC721AUpgradeable}
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev see {IERC721Metadata}
*/
function tokenURI(
uint256 _tokenId
)
public
view
virtual
override(ERC721AUpgradeable, IERC721AUpgradeable)
returns (string memory)
{
}
/**
* @dev see {IERC165-supportsInterface}
*/
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
IERC721AUpgradeable,
ERC2981
)
returns (bool)
{
}
function mintWithSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) public payable nonReentrant {
}
function mintTo(address _to, uint256 _quantity, address _minting_wallet, address _delegated_wallet, string calldata _uid, uint256 _allocation, uint256 _max_supply, uint256 _pricePerUnit, uint256 _expirationTime, bytes calldata _signature) external payable nonReentrant {
}
function _mintTo(ISignatureMinting.RelayMint memory _relay_data) internal {
}
function _executeMint(ISignatureMinting.CartMint memory cart ) internal {
}
/*///////////////////////////////////////////////////////////////
Signature Enforcement
//////////////////////////////////////////////////////////////*/
function revertOnInvalidCartSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) internal view {
}
function revertOnInvalidMintSignature(
address delegated_wallet,
ISignatureMinting.SignatureMintCartItem memory cartItem
) internal view {
}
function _logMintActivity(
string memory uid,
address wallet_address,
uint256 incrementalQuantity
) internal {
}
function setMaxSupply(uint256 _maxSupply) external {
}
function setRoyaltyConfig(address _address, uint96 _royalty) external {
}
function setReceivingWallet(address _address) external {
}
function getReceivingWallet() external view returns (address) {
}
function setFeeManager(address _address, bytes calldata signature) external {
}
function setFeeRecipient(address _address, bytes calldata signature) external {
}
function revertOnInvalidAddressSignature(
address _address,
bytes calldata signature
) internal view {
}
/// @dev Lets a contract admin set a new owner for the contract. The new owner must be a contract admin.
function setOwner(address _newOwner) external {
}
/// @dev Lets a contract admin set the URI for contract-level metadata.
function setContractURI(string calldata _uri) external {
}
/// @dev Lets a contract admin set the URI for the baseURI.
function setBaseURI(string calldata _baseURI) external {
}
function setSignatureVerifier(address _address) external {
}
/*///////////////////////////////////////////////////////////////
Miscellaneous / Overrides
//////////////////////////////////////////////////////////////*/
function togglePause(bool isPaused) external {
}
function grantRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function revokeRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function _hasMinRole(bytes32 _role) internal view returns (bool) {
}
// @dev See {ERC721-_beforeTokenTransfer}.
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override(ERC721AUpgradeable) {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721AUpgradeable, IERC721AUpgradeable) {
require(<FILL_ME>)
require(isTradeable, "Approvals are currently disabled.");
super.setApprovalForAll(operator, approved);
}
function approve(address operator, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function isApprovedForAll(address _owner, address operator) public view override(ERC721AUpgradeable, IERC721AUpgradeable) returns (bool) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
{
}
function _msgSender()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (address sender)
{
}
function _msgData()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (bytes calldata)
{
}
function isSanctioned(address _operatorAddress) public view returns (bool) {
}
function setSanctionsContract(address _address) external {
}
function setVersionOverride(uint256 _version) external {
}
function setRelayAddresses(address[] memory _addresses) external {
}
function setTradability(bool _isTradeable) external {
}
function setSoulbound(bool _isSoulbound) external {
}
/// @dev Returns the number of minted tokens for sender by allowlist.
function getMintedByUid(string calldata _uid, address _wallet) external view returns (uint256) {
}
uint256[46] private ___gap;
}
| onlyAllowedOperatorApproval(operator),"Operator not allowed" | 400,027 | onlyAllowedOperatorApproval(operator) |
"Operator not allowed" | // SPDX-License-Identifier: Apache 2.0
// Powered by @Props
pragma solidity ^0.8.4;
// ========== External imports ==========
import 'erc721a-upgradeable/contracts/ERC721AUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/IERC721AQueryableUpgradeable.sol';
import 'erc721a-upgradeable/contracts/extensions/ERC721ABurnableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/MulticallUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol';
import '@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol';
import '@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@thirdweb-dev/contracts/openzeppelin-presets/metatx/ERC2771ContextUpgradeable.sol';
import '@thirdweb-dev/contracts/feature/interface/IOwnable.sol';
import '@thirdweb-dev/contracts/lib/MerkleProof.sol';
// ========== Internal imports ==========
import "../../interfaces/IPropsInit.sol";
import '../../interfaces/ISignatureMinting.sol';
import '../../interfaces/IPropsContract.sol';
import '../../interfaces/ISanctionsList.sol';
import '../../interfaces/IPropsFeeManager.sol';
import '../../interfaces/IPropsERC721AClaim.sol';
import {DefaultOperatorFiltererUpgradeable} from '../../external/opensea/DefaultOperatorFiltererUpgradeable.sol';
contract PropsERC721AClaim is
Initializable,
IOwnable,
IPropsContract,
ReentrancyGuardUpgradeable,
PausableUpgradeable,
ERC2771ContextUpgradeable,
DefaultOperatorFiltererUpgradeable,
MulticallUpgradeable,
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
ERC721AQueryableUpgradeable,
ERC721ABurnableUpgradeable,
ERC2981
{
using StringsUpgradeable for uint256;
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.Bytes32Set;
using ECDSAUpgradeable for bytes32;
//////////////////////////////////////////////
// State Vars
/////////////////////////////////////////////
bytes32 private constant MODULE_TYPE = bytes32('PropsERC721AClaim');
uint256 private constant VERSION = 15;
uint256 private nextTokenId;
mapping(address => uint256) public minted;
bytes32 private constant CONTRACT_ADMIN_ROLE = keccak256('CONTRACT_ADMIN_ROLE');
bytes32 private constant MINTER_ROLE = keccak256('MINTER_ROLE');
bytes32 private constant PRODUCER_ROLE = keccak256('PRODUCER_ROLE');
mapping(string => mapping(address => uint256)) public mintedByID;
uint256 public MAX_SUPPLY;
string private baseURI_;
string public contractURI;
address private _owner;
address private accessRegistry;
address public project;
address public receivingWallet;
address public rWallet;
address public signatureVerifier;
address[] private trustedForwarders;
address public SANCTIONS_CONTRACT;
address public PROPS_FEE_MANAGER;
address public FEE_RECIPIENT;
uint256 public VERSION_OVERRIDE;
address[] public APPROVED_RELAY_ADDRESSES;
bool public isTradeable;
bool public isSoulbound;
//////////////////////////////////////////////
// Errors
/////////////////////////////////////////////
error AllowlistInactive();
error AllowlistSupplyExhausted();
error MintQuantityInvalid();
error MaxSupplyExhausted();
error MerkleProofInvalid();
error MintClosed();
error InsufficientFunds();
error InvalidSignature();
error Sanctioned();
error ExpiredSignature();
error SoulBound();
//////////////////////////////////////////////
// Events
/////////////////////////////////////////////
event Minted(address indexed account, string tokens);
event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
//////////////////////////////////////////////
// Init
/////////////////////////////////////////////
function initialize(
IPropsInit.InitializeArgs memory args
) public initializerERC721A initializer {
}
/*///////////////////////////////////////////////////////////////
Generic contract logic
//////////////////////////////////////////////////////////////*/
/// @dev Returns the type of the contract.
function contractType() external pure returns (bytes32) {
}
/// @dev Returns the version of the contract.
function contractVersion() external pure returns (uint8) {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/*///////////////////////////////////////////////////////////////
ERC 165 / 721A logic
//////////////////////////////////////////////////////////////*/
/**
* @dev see {ERC721AUpgradeable}
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
/**
* @dev see {IERC721Metadata}
*/
function tokenURI(
uint256 _tokenId
)
public
view
virtual
override(ERC721AUpgradeable, IERC721AUpgradeable)
returns (string memory)
{
}
/**
* @dev see {IERC165-supportsInterface}
*/
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(
AccessControlEnumerableUpgradeable,
ERC721AUpgradeable,
IERC721AUpgradeable,
ERC2981
)
returns (bool)
{
}
function mintWithSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) public payable nonReentrant {
}
function mintTo(address _to, uint256 _quantity, address _minting_wallet, address _delegated_wallet, string calldata _uid, uint256 _allocation, uint256 _max_supply, uint256 _pricePerUnit, uint256 _expirationTime, bytes calldata _signature) external payable nonReentrant {
}
function _mintTo(ISignatureMinting.RelayMint memory _relay_data) internal {
}
function _executeMint(ISignatureMinting.CartMint memory cart ) internal {
}
/*///////////////////////////////////////////////////////////////
Signature Enforcement
//////////////////////////////////////////////////////////////*/
function revertOnInvalidCartSignature(
ISignatureMinting.SignatureClaimCart calldata cart
) internal view {
}
function revertOnInvalidMintSignature(
address delegated_wallet,
ISignatureMinting.SignatureMintCartItem memory cartItem
) internal view {
}
function _logMintActivity(
string memory uid,
address wallet_address,
uint256 incrementalQuantity
) internal {
}
function setMaxSupply(uint256 _maxSupply) external {
}
function setRoyaltyConfig(address _address, uint96 _royalty) external {
}
function setReceivingWallet(address _address) external {
}
function getReceivingWallet() external view returns (address) {
}
function setFeeManager(address _address, bytes calldata signature) external {
}
function setFeeRecipient(address _address, bytes calldata signature) external {
}
function revertOnInvalidAddressSignature(
address _address,
bytes calldata signature
) internal view {
}
/// @dev Lets a contract admin set a new owner for the contract. The new owner must be a contract admin.
function setOwner(address _newOwner) external {
}
/// @dev Lets a contract admin set the URI for contract-level metadata.
function setContractURI(string calldata _uri) external {
}
/// @dev Lets a contract admin set the URI for the baseURI.
function setBaseURI(string calldata _baseURI) external {
}
function setSignatureVerifier(address _address) external {
}
/*///////////////////////////////////////////////////////////////
Miscellaneous / Overrides
//////////////////////////////////////////////////////////////*/
function togglePause(bool isPaused) external {
}
function grantRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function revokeRole(
bytes32 role,
address account
) public virtual override(AccessControlUpgradeable, IAccessControlUpgradeable) {
}
function _hasMinRole(bytes32 _role) internal view returns (bool) {
}
// @dev See {ERC721-_beforeTokenTransfer}.
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override(ERC721AUpgradeable) {
}
function setApprovalForAll(address operator, bool approved) public override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
require(<FILL_ME>)
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721AUpgradeable, IERC721AUpgradeable) {
}
function isApprovedForAll(address _owner, address operator) public view override(ERC721AUpgradeable, IERC721AUpgradeable) returns (bool) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
{
}
function _msgSender()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (address sender)
{
}
function _msgData()
internal
view
virtual
override(ContextUpgradeable, ERC2771ContextUpgradeable)
returns (bytes calldata)
{
}
function isSanctioned(address _operatorAddress) public view returns (bool) {
}
function setSanctionsContract(address _address) external {
}
function setVersionOverride(uint256 _version) external {
}
function setRelayAddresses(address[] memory _addresses) external {
}
function setTradability(bool _isTradeable) external {
}
function setSoulbound(bool _isSoulbound) external {
}
/// @dev Returns the number of minted tokens for sender by allowlist.
function getMintedByUid(string calldata _uid, address _wallet) external view returns (uint256) {
}
uint256[46] private ___gap;
}
| onlyAllowedOperatorApproval(from),"Operator not allowed" | 400,027 | onlyAllowedOperatorApproval(from) |
"Minting is not active" | // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
// 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.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
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 Merkle 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) {
}
}
pragma solidity ^0.8.0;
contract NorfFC is Ownable, ERC721A, ReentrancyGuard {
uint256 constant MAX_ELEMENTS = 1966;
uint256 constant MAX_ELEMENT_PER_USER = 2;
uint256 constant MAX_ELEMENTS_ONE_TIME = 2;
// state variable
bool public MINTING_PAUSED = true;
string public baseTokenURI;
string public _contractURI = "";
mapping(address => uint256) private freeMemberList;
constructor(uint256 maxBatchSize_) ERC721A("NorfFc", "NORFFC", maxBatchSize_) {}
function setPauseMinting(bool _pause) public onlyOwner {
}
function getMintCount(address _addr) public view returns (uint256) {
}
function freeMint(uint256 numberOfTokens) external payable {
require(<FILL_ME>)
require(totalSupply() < MAX_ELEMENTS, 'All tokens have been minted');
require(freeMemberList[msg.sender] + numberOfTokens <= MAX_ELEMENT_PER_USER, 'Your free purchase would exceed max(2) supply');
require(numberOfTokens <= MAX_ELEMENTS_ONE_TIME,"Purchase at a time exceeds max allowed");
_safeMint(msg.sender, numberOfTokens);
freeMemberList[msg.sender] += numberOfTokens;
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
}
| !MINTING_PAUSED,"Minting is not active" | 400,035 | !MINTING_PAUSED |
'All tokens have been minted' | // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
// 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.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
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 Merkle 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) {
}
}
pragma solidity ^0.8.0;
contract NorfFC is Ownable, ERC721A, ReentrancyGuard {
uint256 constant MAX_ELEMENTS = 1966;
uint256 constant MAX_ELEMENT_PER_USER = 2;
uint256 constant MAX_ELEMENTS_ONE_TIME = 2;
// state variable
bool public MINTING_PAUSED = true;
string public baseTokenURI;
string public _contractURI = "";
mapping(address => uint256) private freeMemberList;
constructor(uint256 maxBatchSize_) ERC721A("NorfFc", "NORFFC", maxBatchSize_) {}
function setPauseMinting(bool _pause) public onlyOwner {
}
function getMintCount(address _addr) public view returns (uint256) {
}
function freeMint(uint256 numberOfTokens) external payable {
require(!MINTING_PAUSED, "Minting is not active");
require(<FILL_ME>)
require(freeMemberList[msg.sender] + numberOfTokens <= MAX_ELEMENT_PER_USER, 'Your free purchase would exceed max(2) supply');
require(numberOfTokens <= MAX_ELEMENTS_ONE_TIME,"Purchase at a time exceeds max allowed");
_safeMint(msg.sender, numberOfTokens);
freeMemberList[msg.sender] += numberOfTokens;
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
}
| totalSupply()<MAX_ELEMENTS,'All tokens have been minted' | 400,035 | totalSupply()<MAX_ELEMENTS |
'Your free purchase would exceed max(2) supply' | // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
// 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.
*
* WARNING: You should avoid using leaf values that are 64 bytes long prior to
* hashing, or use a hash function other than keccak256 for hashing leaves.
* This is because the concatenation of a sorted pair of internal nodes in
* the merkle tree could be reinterpreted as a leaf value.
*/
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 Merkle 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) {
}
}
pragma solidity ^0.8.0;
contract NorfFC is Ownable, ERC721A, ReentrancyGuard {
uint256 constant MAX_ELEMENTS = 1966;
uint256 constant MAX_ELEMENT_PER_USER = 2;
uint256 constant MAX_ELEMENTS_ONE_TIME = 2;
// state variable
bool public MINTING_PAUSED = true;
string public baseTokenURI;
string public _contractURI = "";
mapping(address => uint256) private freeMemberList;
constructor(uint256 maxBatchSize_) ERC721A("NorfFc", "NORFFC", maxBatchSize_) {}
function setPauseMinting(bool _pause) public onlyOwner {
}
function getMintCount(address _addr) public view returns (uint256) {
}
function freeMint(uint256 numberOfTokens) external payable {
require(!MINTING_PAUSED, "Minting is not active");
require(totalSupply() < MAX_ELEMENTS, 'All tokens have been minted');
require(<FILL_ME>)
require(numberOfTokens <= MAX_ELEMENTS_ONE_TIME,"Purchase at a time exceeds max allowed");
_safeMint(msg.sender, numberOfTokens);
freeMemberList[msg.sender] += numberOfTokens;
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) public onlyOwner {
}
function setContractURI(string calldata URI) external onlyOwner {
}
function contractURI() public view returns (string memory) {
}
}
| freeMemberList[msg.sender]+numberOfTokens<=MAX_ELEMENT_PER_USER,'Your free purchase would exceed max(2) supply' | 400,035 | freeMemberList[msg.sender]+numberOfTokens<=MAX_ELEMENT_PER_USER |
ERROR_REINITIALIZATION_NOT_PERMITTED | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC721.sol";
import "../interfaces/IERC721DefaultOwnerCloneable.sol";
abstract contract ERC721Omnibus is ERC721, IERC721DefaultOwnerCloneable {
struct TokenOwner {
bool transferred;
address ownerAddress;
}
struct CollectionStatus {
bool isContractFinalized; // 1 byte
uint88 amountCreated; // 11 bytes
address defaultOwner; // 20 bytes
}
// Only allow Nifty Entity to be initialized once
bool internal initializedDefaultOwner;
CollectionStatus internal collectionStatus;
// Mapping from token ID to owner address
mapping(uint256 => TokenOwner) internal ownersOptimized;
function initializeDefaultOwner(address defaultOwner_) public {
require(<FILL_ME>)
collectionStatus.defaultOwner = defaultOwner_;
initializedDefaultOwner = true;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, IERC165) returns (bool) {
}
function getCollectionStatus() public view virtual returns (CollectionStatus memory) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address owner) {
}
function _exists(uint256 tokenId) internal view virtual override returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual override returns (address owner, bool isApprovedOrOwner) {
}
function _clearOwnership(uint256 tokenId) internal virtual override {
}
function _setOwnership(address to, uint256 tokenId) internal virtual override {
}
function _isValidTokenId(uint256 /*tokenId*/) internal virtual view returns (bool);
}
| !initializedDefaultOwner,ERROR_REINITIALIZATION_NOT_PERMITTED | 400,036 | !initializedDefaultOwner |
ERROR_QUERY_FOR_NONEXISTENT_TOKEN | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC721.sol";
import "../interfaces/IERC721DefaultOwnerCloneable.sol";
abstract contract ERC721Omnibus is ERC721, IERC721DefaultOwnerCloneable {
struct TokenOwner {
bool transferred;
address ownerAddress;
}
struct CollectionStatus {
bool isContractFinalized; // 1 byte
uint88 amountCreated; // 11 bytes
address defaultOwner; // 20 bytes
}
// Only allow Nifty Entity to be initialized once
bool internal initializedDefaultOwner;
CollectionStatus internal collectionStatus;
// Mapping from token ID to owner address
mapping(uint256 => TokenOwner) internal ownersOptimized;
function initializeDefaultOwner(address defaultOwner_) public {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, IERC165) returns (bool) {
}
function getCollectionStatus() public view virtual returns (CollectionStatus memory) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address owner) {
require(<FILL_ME>)
owner = ownersOptimized[tokenId].transferred ? ownersOptimized[tokenId].ownerAddress : collectionStatus.defaultOwner;
require(owner != address(0), ERROR_QUERY_FOR_NONEXISTENT_TOKEN);
}
function _exists(uint256 tokenId) internal view virtual override returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual override returns (address owner, bool isApprovedOrOwner) {
}
function _clearOwnership(uint256 tokenId) internal virtual override {
}
function _setOwnership(address to, uint256 tokenId) internal virtual override {
}
function _isValidTokenId(uint256 /*tokenId*/) internal virtual view returns (bool);
}
| _isValidTokenId(tokenId),ERROR_QUERY_FOR_NONEXISTENT_TOKEN | 400,036 | _isValidTokenId(tokenId) |
ERROR_REINITIALIZATION_NOT_PERMITTED | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "./ERC721Errors.sol";
import "../interfaces/IERC721.sol";
import "../interfaces/IERC721Receiver.sol";
import "../interfaces/IERC721Metadata.sol";
import "../interfaces/IERC721Cloneable.sol";
import "../libraries/Address.sol";
import "../libraries/Context.sol";
import "../libraries/Strings.sol";
import "../utils/ERC165.sol";
import "../utils/GenericErrors.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
abstract contract ERC721 is Context, ERC165, ERC721Errors, GenericErrors, IERC721Metadata, IERC721Cloneable {
using Address for address;
using Strings for uint256;
// Only allow ERC721 to be initialized once
bool internal initializedERC721;
// Token name
string internal tokenName;
// Token symbol
string internal tokenSymbol;
// Base URI For Offchain Metadata
string internal baseMetadataURI;
// Mapping from token ID to owner address
mapping(uint256 => address) internal owners;
// Mapping owner address to token count
mapping(address => uint256) internal balances;
// Mapping from token ID to approved address
mapping(uint256 => address) internal tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) internal operatorApprovals;
function initializeERC721(string memory name_, string memory symbol_, string memory baseURI_) public override {
require(<FILL_ME>)
tokenName = name_;
tokenSymbol = symbol_;
_setBaseURI(baseURI_);
initializedERC721 = true;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function baseURI() public view virtual returns (string memory) {
}
/**
* @dev Storefront-level metadata for contract
*/
function contractURI() public view virtual returns (string memory) {
}
/**
* @dev Internal function to set the base URI
*/
function _setBaseURI(string memory uri) internal {
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (address owner, bool isApprovedOrOwner) {
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address owner, address from, address to, uint256 tokenId) internal virtual {
}
/**
* @dev Equivalent to approving address(0), but more gas efficient
*
* Emits a {Approval} event.
*/
function _clearApproval(address owner, uint256 tokenId) internal virtual {
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits a {Approval} event.
*/
function _approve(address owner, address to, uint256 tokenId) internal virtual {
}
function _clearOwnership(uint256 tokenId) internal virtual {
}
function _setOwnership(address to, uint256 tokenId) internal virtual {
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*
* @dev Slither identifies an issue with unused return value.
* Reference: https://github.com/crytic/slither/wiki/Detector-Documentation#unused-return
* This should be a non-issue. It is the standard OpenZeppelin implementation which has been heavily used and audited.
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal returns (bool) {
}
}
| !initializedERC721,ERROR_REINITIALIZATION_NOT_PERMITTED | 400,044 | !initializedERC721 |
"It's loading :: Already minted maximum times!" | pragma solidity ^0.8.0;
contract ItsLoading is ERC721A, Ownable{
using StringsUpgradeable for uint256;
uint256 public constant MAX_SUPPLY = 1111;
uint256 public constant MAX_PUBLIC_MINT = 1;
uint256 public constant MAX_WHITELIST_MINT = 1;
string public baseTokenURI;
bool public publicSale;
bool public whiteListSale;
bytes32 private merkleRoot;
mapping(address => uint256) public totalPublicMint;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("It's loading", "LOADING"){
}
modifier callerIsUser() {
}
function mint() external callerIsUser {
require(publicSale, "It's loading :: Not Yet Active.");
require((totalSupply() + 1) <= MAX_SUPPLY, "It's loading :: Beyond Max Supply");
require(<FILL_ME>)
totalPublicMint[msg.sender] += 1;
_safeMint(msg.sender, 1);
}
function whitelistMint(bytes32[] memory _merkleProof) external callerIsUser {
}
/// @notice Set baseURI
/// @param baseURI URI of the IPFS image server
function setBaseURI(string memory baseURI) external onlyOwner {
}
/// @notice Get uri of tokens
/// @return string Uri
function _baseURI() internal view virtual override returns (string memory) {
}
//return uri for certain token
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenUri(string memory _baseTokenUri) external onlyOwner{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function getMerkleRoot() external view returns (bytes32){
}
function toggleWhiteListSale() external onlyOwner{
}
function togglePublicSale() external onlyOwner{
}
}
| (totalPublicMint[msg.sender]+1)<=MAX_PUBLIC_MINT,"It's loading :: Already minted maximum times!" | 400,094 | (totalPublicMint[msg.sender]+1)<=MAX_PUBLIC_MINT |
"It's loading :: Cannot mint beyond whitelist max mint!" | pragma solidity ^0.8.0;
contract ItsLoading is ERC721A, Ownable{
using StringsUpgradeable for uint256;
uint256 public constant MAX_SUPPLY = 1111;
uint256 public constant MAX_PUBLIC_MINT = 1;
uint256 public constant MAX_WHITELIST_MINT = 1;
string public baseTokenURI;
bool public publicSale;
bool public whiteListSale;
bytes32 private merkleRoot;
mapping(address => uint256) public totalPublicMint;
mapping(address => uint256) public totalWhitelistMint;
constructor() ERC721A("It's loading", "LOADING"){
}
modifier callerIsUser() {
}
function mint() external callerIsUser {
}
function whitelistMint(bytes32[] memory _merkleProof) external callerIsUser {
require(whiteListSale, "It's loading :: Minting is on Pause");
require((totalSupply() + 1) <= MAX_SUPPLY, "It's loading :: Cannot mint beyond max supply");
require(<FILL_ME>)
//create leaf node
bytes32 sender = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_merkleProof, merkleRoot, sender), "It's loading :: You are not on the whitelist");
totalWhitelistMint[msg.sender] += 1;
_safeMint(msg.sender, 1);
}
/// @notice Set baseURI
/// @param baseURI URI of the IPFS image server
function setBaseURI(string memory baseURI) external onlyOwner {
}
/// @notice Get uri of tokens
/// @return string Uri
function _baseURI() internal view virtual override returns (string memory) {
}
//return uri for certain token
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setTokenUri(string memory _baseTokenUri) external onlyOwner{
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner{
}
function getMerkleRoot() external view returns (bytes32){
}
function toggleWhiteListSale() external onlyOwner{
}
function togglePublicSale() external onlyOwner{
}
}
| (totalWhitelistMint[msg.sender]+1)<=MAX_WHITELIST_MINT,"It's loading :: Cannot mint beyond whitelist max mint!" | 400,094 | (totalWhitelistMint[msg.sender]+1)<=MAX_WHITELIST_MINT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.