comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"CompoundPool::deposit: Compound mint failed" | /**
* @title CompoundPool
* @author Nate Welch <github.com/flyging>
* @notice Based on Zefram Lou's implementation https://github.com/ZeframLou/pooled-cdai
* @dev A bank that will pool compound tokens and allows the beneficiary to withdraw
*/
contract CompoundPool is ERC20, ERC20Detailed, Ownable {
using SafeMath for uint;
uint256 internal constant PRECISION = 10 ** 18;
ICompoundERC20 public compoundToken;
IERC20 public depositToken;
address public governance;
address public beneficiary;
/**
* @notice Constructor
* @param _name name of the pool share token
* @param _symbol symbol of the pool share token
* @param _comptroller the Compound Comptroller contract used to enter the compoundToken's market
* @param _compoundToken the Compound Token contract (e.g. cDAI)
* @param _depositToken the Deposit Token contract (e.g. DAI)
* @param _beneficiary the address that can withdraw excess deposit tokens (interest/donations)
*/
constructor(
string memory _name,
string memory _symbol,
IComptroller _comptroller,
ICompoundERC20 _compoundToken,
IERC20 _depositToken,
address _beneficiary
)
ERC20Detailed(_name, _symbol, 18)
public
{
}
/**
* @dev used to restrict access of functions to the current beneficiary
*/
modifier onlyBeneficiary() {
}
/**
* @notice Called by the `owner` to set a new beneficiary
* @dev This function will fail if called by a non-owner address
* @param _newBeneficiary The address that will become the new beneficiary
*/
function updateBeneficiary(address _newBeneficiary) public onlyOwner {
}
/**
* @notice The beneficiary calls this function to withdraw excess deposit tokens
* @dev This function will fail if called by a non-beneficiary or if _amount is higher than the excess deposit tokens
* @param _to The address that the deposit tokens will be sent to
* @param _amount The amount of deposit tokens to send to the `_to` address
*/
function withdrawInterest(address _to, uint256 _amount) public onlyBeneficiary returns (uint256) {
}
/**
* @notice Called by someone wishing to deposit to the bank. This amount, plus previous user's balance, will always be withdrawable
* @dev Allowance for CompoundPool to transferFrom the msg.sender's balance must be set on the deposit token
* @param _amount The amount of deposit tokens to deposit
*/
function deposit(uint256 _amount) public {
require(depositToken.transferFrom(msg.sender, address(this), _amount), "CompoundPool::deposit: Transfer failed");
_approveDepositToken(_amount);
require(<FILL_ME>)
_mint(msg.sender, _amount);
}
/**
* @notice Called by someone wishing to withdraw from the bank
* @dev This will fail if msg.sender doesn't have at least _amount pool share tokens
* @param _amount The amount of deposit tokens to withdraw
*/
function withdraw(uint256 _amount) public {
}
/**
* @notice Called by someone wishing to donate to the bank. This amount will *not* be added to users balance, and will be usable by the beneficiary.
* @dev Allowance for CompoundPool to transferFrom the msg.sender's balance must be set on the deposit token
* @param _amount The amount of deposit tokens to donate
*/
function donate(uint256 _amount) public {
}
/**
* @notice Returns the amount of deposit tokens that are usable by the beneficiary. Basically, interestEarned+donations
* @dev Allowance for CompoundPool to transferFrom the msg.sender's balance must be set on the deposit token
*/
function excessDepositTokens() public returns (uint256) {
}
function depositTokenStoredBalance() internal returns (uint256) {
}
function _approveDepositToken(uint256 _minimum) internal {
}
}
| compoundToken.mint(_amount)==0,"CompoundPool::deposit: Compound mint failed" | 59,243 | compoundToken.mint(_amount)==0 |
"CompoundPool::withdraw: Transfer failed" | /**
* @title CompoundPool
* @author Nate Welch <github.com/flyging>
* @notice Based on Zefram Lou's implementation https://github.com/ZeframLou/pooled-cdai
* @dev A bank that will pool compound tokens and allows the beneficiary to withdraw
*/
contract CompoundPool is ERC20, ERC20Detailed, Ownable {
using SafeMath for uint;
uint256 internal constant PRECISION = 10 ** 18;
ICompoundERC20 public compoundToken;
IERC20 public depositToken;
address public governance;
address public beneficiary;
/**
* @notice Constructor
* @param _name name of the pool share token
* @param _symbol symbol of the pool share token
* @param _comptroller the Compound Comptroller contract used to enter the compoundToken's market
* @param _compoundToken the Compound Token contract (e.g. cDAI)
* @param _depositToken the Deposit Token contract (e.g. DAI)
* @param _beneficiary the address that can withdraw excess deposit tokens (interest/donations)
*/
constructor(
string memory _name,
string memory _symbol,
IComptroller _comptroller,
ICompoundERC20 _compoundToken,
IERC20 _depositToken,
address _beneficiary
)
ERC20Detailed(_name, _symbol, 18)
public
{
}
/**
* @dev used to restrict access of functions to the current beneficiary
*/
modifier onlyBeneficiary() {
}
/**
* @notice Called by the `owner` to set a new beneficiary
* @dev This function will fail if called by a non-owner address
* @param _newBeneficiary The address that will become the new beneficiary
*/
function updateBeneficiary(address _newBeneficiary) public onlyOwner {
}
/**
* @notice The beneficiary calls this function to withdraw excess deposit tokens
* @dev This function will fail if called by a non-beneficiary or if _amount is higher than the excess deposit tokens
* @param _to The address that the deposit tokens will be sent to
* @param _amount The amount of deposit tokens to send to the `_to` address
*/
function withdrawInterest(address _to, uint256 _amount) public onlyBeneficiary returns (uint256) {
}
/**
* @notice Called by someone wishing to deposit to the bank. This amount, plus previous user's balance, will always be withdrawable
* @dev Allowance for CompoundPool to transferFrom the msg.sender's balance must be set on the deposit token
* @param _amount The amount of deposit tokens to deposit
*/
function deposit(uint256 _amount) public {
}
/**
* @notice Called by someone wishing to withdraw from the bank
* @dev This will fail if msg.sender doesn't have at least _amount pool share tokens
* @param _amount The amount of deposit tokens to withdraw
*/
function withdraw(uint256 _amount) public {
_burn(msg.sender, _amount);
require(compoundToken.redeemUnderlying(_amount) == 0, "CompoundPool::withdraw: Compound redeem failed");
require(<FILL_ME>)
}
/**
* @notice Called by someone wishing to donate to the bank. This amount will *not* be added to users balance, and will be usable by the beneficiary.
* @dev Allowance for CompoundPool to transferFrom the msg.sender's balance must be set on the deposit token
* @param _amount The amount of deposit tokens to donate
*/
function donate(uint256 _amount) public {
}
/**
* @notice Returns the amount of deposit tokens that are usable by the beneficiary. Basically, interestEarned+donations
* @dev Allowance for CompoundPool to transferFrom the msg.sender's balance must be set on the deposit token
*/
function excessDepositTokens() public returns (uint256) {
}
function depositTokenStoredBalance() internal returns (uint256) {
}
function _approveDepositToken(uint256 _minimum) internal {
}
}
| depositToken.transfer(msg.sender,_amount),"CompoundPool::withdraw: Transfer failed" | 59,243 | depositToken.transfer(msg.sender,_amount) |
"Liquidity Pool Token has not been set yet" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
import "../Dependencies/LiquityMath.sol";
import "../Dependencies/SafeMath.sol";
import "../Dependencies/Ownable.sol";
import "../Dependencies/CheckContract.sol";
import "../Interfaces/ILQTYToken.sol";
import "./Dependencies/SafeERC20.sol";
import "./Interfaces/ILPTokenWrapper.sol";
import "./Interfaces/IUnipool.sol";
import "../Dependencies/console.sol";
// Adapted from: https://github.com/Synthetixio/Unipool/blob/master/contracts/Unipool.sol
// Some more useful references:
// Synthetix proposal: https://sips.synthetix.io/sips/sip-31
// Original audit: https://github.com/sigp/public-audits/blob/master/synthetix/unipool/review.pdf
// Incremental changes (commit by commit) from the original to this version: https://github.com/liquity/dev/pull/271
// LPTokenWrapper contains the basic staking functionality
contract LPTokenWrapper is ILPTokenWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public uniToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function stake(uint256 amount) public virtual override {
}
function withdraw(uint256 amount) public virtual override {
}
}
/*
* On deployment a new Uniswap pool will be created for the pair LUSD/ETH and its token will be set here.
* Essentially the way it works is:
* - Liquidity providers add funds to the Uniswap pool, and get UNIv2 LP tokens in exchange
* - Liquidity providers stake those UNIv2 LP tokens into Unipool rewards contract
* - Liquidity providers accrue rewards, proportional to the amount of staked tokens and staking time
* - Liquidity providers can claim their rewards when they want
* - Liquidity providers can unstake UNIv2 LP tokens to exit the program (i.e., stop earning rewards) when they want
* Funds for rewards will only be added once, on deployment of LQTY token,
* which will happen after this contract is deployed and before this `setParams` in this contract is called.
* If at some point the total amount of staked tokens is zero, the clock will be “stopped”,
* so the period will be extended by the time during which the staking pool is empty,
* in order to avoid getting LQTY tokens locked.
* That also means that the start time for the program will be the event that occurs first:
* either LQTY token contract is deployed, and therefore LQTY tokens are minted to Unipool contract,
* or first liquidity provider stakes UNIv2 LP tokens into it.
*/
contract Unipool is LPTokenWrapper, Ownable, CheckContract, IUnipool {
string constant public NAME = "Unipool";
uint256 public duration;
ILQTYToken public lqtyToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event LQTYTokenAddressChanged(address _lqtyTokenAddress);
event UniTokenAddressChanged(address _uniTokenAddress);
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
// initialization function
function setParams(
address _lqtyTokenAddress,
address _uniTokenAddress,
uint _duration
)
external
override
onlyOwner
{
}
// Returns current timestamp if the rewards program has not finished yet, end time otherwise
function lastTimeRewardApplicable() public view override returns (uint256) {
}
// Returns the amount of rewards that correspond to each staked token
function rewardPerToken() public view override returns (uint256) {
}
// Returns the amount that an account can claim
function earned(address account) public view override returns (uint256) {
}
// stake visibility is public as overriding LPTokenWrapper's stake() function
function stake(uint256 amount) public override {
require(amount > 0, "Cannot stake 0");
require(<FILL_ME>)
_updatePeriodFinish();
_updateAccountReward(msg.sender);
super.stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override {
}
// Shortcut to be able to unstake tokens and claim rewards in one transaction
function withdrawAndClaim() external override {
}
function claimReward() public override {
}
// Used only on initialization, sets the reward rate and the end time for the program
function _notifyRewardAmount(uint256 _reward, uint256 _duration) internal {
}
// Adjusts end time for the program after periods of zero total supply
function _updatePeriodFinish() internal {
}
function _updateReward() internal {
}
function _updateAccountReward(address account) internal {
}
}
| address(uniToken)!=address(0),"Liquidity Pool Token has not been set yet" | 59,280 | address(uniToken)!=address(0) |
"Not authorized" | pragma solidity ^0.8.0;
/*
*
* ______ _____ _____ _ _ ______ _______
* | ____|_ _| __ \ | \ | | ____|__ __|
* | |__ | | | |__) | | \| | |__ | |
* | __| | | | ___/ | . ` | __| | |
* | |____ _| |_| | | |\ | | | |
* |______|_____|_| |_| \_|_| |_|
* created by @aka_labs_, 2021
*
*/
contract EIPNFT is IERC2981, ERC721 {
using ECDSA for bytes32;
using Strings for uint256;
using Strings for uint16;
uint24 internal defaultBips;
address public owner;
uint256 internal immutable top;
uint256 internal immutable middle;
mapping(uint256 => address) internal _receiverAddresses;
struct MintInfo {
uint16 mintCount;
bool mintingComplete;
string dateCreated;
string eipDescription;
}
// Minting Information for a given EIP
mapping(uint256 => MintInfo) internal _mintInfo;
constructor(address _owner, uint24 _defaultBips) ERC721("Ethereum Improvement Proposal - NFTs", "EIP", "") {
}
function _encodeTokenId(uint256 eipNumber, uint256 tokenNumber) internal view returns (uint256) {
}
function _getEIPNumber(uint256 tokenId) internal view returns (uint256) {
}
function _getTokenNumber(uint256 tokenId) internal view returns (uint256) {
}
function authenticatedMint(
uint96 _eipNumber,
uint8 _maxMints,
address _authorAddress,
string memory _dateCreated,
string memory _eipDescription,
bytes memory _authSignature
) public {
require(<FILL_ME>)
MintInfo storage currentMintInfo = _mintInfo[_eipNumber];
uint256 tokenNumber = currentMintInfo.mintCount + 1;
if (bytes(_dateCreated).length > 0) {
currentMintInfo.dateCreated = _dateCreated;
}
if (bytes(_eipDescription).length > 0) {
currentMintInfo.eipDescription = _eipDescription;
}
require(!currentMintInfo.mintingComplete, "Too many mints");
// Set mintingComplete flag to true when on the last mint for an EIP.
// Contract owner can't issue new NFTs for thie EIP after this point.
if (tokenNumber == _maxMints) {
currentMintInfo.mintingComplete = true;
}
if (super.balanceOf(_authorAddress) != 0) {
for (uint256 i = 1; i <= _maxMints; i++) {
uint256 currentTokenId = _encodeTokenId(_eipNumber, i);
if (_exists(currentTokenId)) {
require(super.ownerOf(currentTokenId) != _authorAddress, "Already minted");
}
}
}
uint256 tokenId = _encodeTokenId(_eipNumber, tokenNumber);
safeMint(tokenId, _authorAddress);
_receiverAddresses[tokenId] = _authorAddress;
currentMintInfo.mintCount += 1;
}
function verifyMint(
uint96 _eipNumber,
uint8 _maxMints,
address _authorAddress,
string memory _dateCreated,
string memory _eipDescription,
bytes memory _authSignature
) public view returns (bool) {
}
function safeMint(uint256 tokenId, address _authorAddress) internal virtual {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @inheritdoc IERC2981
function royaltyInfo(uint256 tokenId, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function transferOwnership(address newOwner) public {
}
}
| verifyMint(_eipNumber,_maxMints,_authorAddress,_dateCreated,_eipDescription,_authSignature),"Not authorized" | 59,301 | verifyMint(_eipNumber,_maxMints,_authorAddress,_dateCreated,_eipDescription,_authSignature) |
"Too many mints" | pragma solidity ^0.8.0;
/*
*
* ______ _____ _____ _ _ ______ _______
* | ____|_ _| __ \ | \ | | ____|__ __|
* | |__ | | | |__) | | \| | |__ | |
* | __| | | | ___/ | . ` | __| | |
* | |____ _| |_| | | |\ | | | |
* |______|_____|_| |_| \_|_| |_|
* created by @aka_labs_, 2021
*
*/
contract EIPNFT is IERC2981, ERC721 {
using ECDSA for bytes32;
using Strings for uint256;
using Strings for uint16;
uint24 internal defaultBips;
address public owner;
uint256 internal immutable top;
uint256 internal immutable middle;
mapping(uint256 => address) internal _receiverAddresses;
struct MintInfo {
uint16 mintCount;
bool mintingComplete;
string dateCreated;
string eipDescription;
}
// Minting Information for a given EIP
mapping(uint256 => MintInfo) internal _mintInfo;
constructor(address _owner, uint24 _defaultBips) ERC721("Ethereum Improvement Proposal - NFTs", "EIP", "") {
}
function _encodeTokenId(uint256 eipNumber, uint256 tokenNumber) internal view returns (uint256) {
}
function _getEIPNumber(uint256 tokenId) internal view returns (uint256) {
}
function _getTokenNumber(uint256 tokenId) internal view returns (uint256) {
}
function authenticatedMint(
uint96 _eipNumber,
uint8 _maxMints,
address _authorAddress,
string memory _dateCreated,
string memory _eipDescription,
bytes memory _authSignature
) public {
require(
verifyMint(_eipNumber, _maxMints, _authorAddress, _dateCreated, _eipDescription, _authSignature),
"Not authorized"
);
MintInfo storage currentMintInfo = _mintInfo[_eipNumber];
uint256 tokenNumber = currentMintInfo.mintCount + 1;
if (bytes(_dateCreated).length > 0) {
currentMintInfo.dateCreated = _dateCreated;
}
if (bytes(_eipDescription).length > 0) {
currentMintInfo.eipDescription = _eipDescription;
}
require(<FILL_ME>)
// Set mintingComplete flag to true when on the last mint for an EIP.
// Contract owner can't issue new NFTs for thie EIP after this point.
if (tokenNumber == _maxMints) {
currentMintInfo.mintingComplete = true;
}
if (super.balanceOf(_authorAddress) != 0) {
for (uint256 i = 1; i <= _maxMints; i++) {
uint256 currentTokenId = _encodeTokenId(_eipNumber, i);
if (_exists(currentTokenId)) {
require(super.ownerOf(currentTokenId) != _authorAddress, "Already minted");
}
}
}
uint256 tokenId = _encodeTokenId(_eipNumber, tokenNumber);
safeMint(tokenId, _authorAddress);
_receiverAddresses[tokenId] = _authorAddress;
currentMintInfo.mintCount += 1;
}
function verifyMint(
uint96 _eipNumber,
uint8 _maxMints,
address _authorAddress,
string memory _dateCreated,
string memory _eipDescription,
bytes memory _authSignature
) public view returns (bool) {
}
function safeMint(uint256 tokenId, address _authorAddress) internal virtual {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @inheritdoc IERC2981
function royaltyInfo(uint256 tokenId, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function transferOwnership(address newOwner) public {
}
}
| !currentMintInfo.mintingComplete,"Too many mints" | 59,301 | !currentMintInfo.mintingComplete |
"Already minted" | pragma solidity ^0.8.0;
/*
*
* ______ _____ _____ _ _ ______ _______
* | ____|_ _| __ \ | \ | | ____|__ __|
* | |__ | | | |__) | | \| | |__ | |
* | __| | | | ___/ | . ` | __| | |
* | |____ _| |_| | | |\ | | | |
* |______|_____|_| |_| \_|_| |_|
* created by @aka_labs_, 2021
*
*/
contract EIPNFT is IERC2981, ERC721 {
using ECDSA for bytes32;
using Strings for uint256;
using Strings for uint16;
uint24 internal defaultBips;
address public owner;
uint256 internal immutable top;
uint256 internal immutable middle;
mapping(uint256 => address) internal _receiverAddresses;
struct MintInfo {
uint16 mintCount;
bool mintingComplete;
string dateCreated;
string eipDescription;
}
// Minting Information for a given EIP
mapping(uint256 => MintInfo) internal _mintInfo;
constructor(address _owner, uint24 _defaultBips) ERC721("Ethereum Improvement Proposal - NFTs", "EIP", "") {
}
function _encodeTokenId(uint256 eipNumber, uint256 tokenNumber) internal view returns (uint256) {
}
function _getEIPNumber(uint256 tokenId) internal view returns (uint256) {
}
function _getTokenNumber(uint256 tokenId) internal view returns (uint256) {
}
function authenticatedMint(
uint96 _eipNumber,
uint8 _maxMints,
address _authorAddress,
string memory _dateCreated,
string memory _eipDescription,
bytes memory _authSignature
) public {
require(
verifyMint(_eipNumber, _maxMints, _authorAddress, _dateCreated, _eipDescription, _authSignature),
"Not authorized"
);
MintInfo storage currentMintInfo = _mintInfo[_eipNumber];
uint256 tokenNumber = currentMintInfo.mintCount + 1;
if (bytes(_dateCreated).length > 0) {
currentMintInfo.dateCreated = _dateCreated;
}
if (bytes(_eipDescription).length > 0) {
currentMintInfo.eipDescription = _eipDescription;
}
require(!currentMintInfo.mintingComplete, "Too many mints");
// Set mintingComplete flag to true when on the last mint for an EIP.
// Contract owner can't issue new NFTs for thie EIP after this point.
if (tokenNumber == _maxMints) {
currentMintInfo.mintingComplete = true;
}
if (super.balanceOf(_authorAddress) != 0) {
for (uint256 i = 1; i <= _maxMints; i++) {
uint256 currentTokenId = _encodeTokenId(_eipNumber, i);
if (_exists(currentTokenId)) {
require(<FILL_ME>)
}
}
}
uint256 tokenId = _encodeTokenId(_eipNumber, tokenNumber);
safeMint(tokenId, _authorAddress);
_receiverAddresses[tokenId] = _authorAddress;
currentMintInfo.mintCount += 1;
}
function verifyMint(
uint96 _eipNumber,
uint8 _maxMints,
address _authorAddress,
string memory _dateCreated,
string memory _eipDescription,
bytes memory _authSignature
) public view returns (bool) {
}
function safeMint(uint256 tokenId, address _authorAddress) internal virtual {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// @inheritdoc IERC2981
function royaltyInfo(uint256 tokenId, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function transferOwnership(address newOwner) public {
}
}
| super.ownerOf(currentTokenId)!=_authorAddress,"Already minted" | 59,301 | super.ownerOf(currentTokenId)!=_authorAddress |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath{
function mul(uint256 a, uint256 b) internal pure returns (uint256)
{
}
function div(uint256 a, uint256 b) internal pure returns (uint256)
{
}
function sub(uint256 a, uint256 b) internal pure returns (uint256)
{
}
function add(uint256 a, uint256 b) internal pure returns (uint256)
{
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
interface ERC20Basic {
function balanceOf(address who) external view returns (uint256 balance);
function transfer(address to, uint256 value) external returns (bool trans1);
function allowance(address owner, address spender) external view returns (uint256 remaining);
function transferFrom(address from, address to, uint256 value) external returns (bool trans);
function approve(address spender, uint256 value) external returns (bool hello);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Staker {
using SafeMath for uint;
ERC20Basic public xDNA;
uint[] timespans = [2592000, 7776000, 15552000, 31536000];
uint[] rates = [103, 110, 123, 149];
mapping(uint => address) public ownerOf;
struct Stake {
uint amount;
uint start;
uint8 timespan;
bool withdrawn;
}
Stake[] public stakes;
function stake(uint _amount, uint8 _timespan) public returns (uint _tokenId) {
require(_amount >= 100000 ether);
require(_timespan < 4);
require(<FILL_ME>)
Stake memory _stake = Stake({
amount: _amount,
start: block.timestamp,
timespan: _timespan,
withdrawn: false
});
_tokenId = stakes.length;
stakes.push(_stake);
ownerOf[_tokenId] = msg.sender;
}
function unstake(uint _id) public {
}
function tokensOf(address _owner) public view returns (uint[] memory ownerTokens) {
}
constructor (ERC20Basic _token) {
}
}
| xDNA.transferFrom(msg.sender,address(this),_amount) | 59,304 | xDNA.transferFrom(msg.sender,address(this),_amount) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath{
function mul(uint256 a, uint256 b) internal pure returns (uint256)
{
}
function div(uint256 a, uint256 b) internal pure returns (uint256)
{
}
function sub(uint256 a, uint256 b) internal pure returns (uint256)
{
}
function add(uint256 a, uint256 b) internal pure returns (uint256)
{
}
}
/**
* @title ERC20Basic
* @dev Simpler version of ERC20 interface
* @dev see https://github.com/ethereum/EIPs/issues/179
*/
interface ERC20Basic {
function balanceOf(address who) external view returns (uint256 balance);
function transfer(address to, uint256 value) external returns (bool trans1);
function allowance(address owner, address spender) external view returns (uint256 remaining);
function transferFrom(address from, address to, uint256 value) external returns (bool trans);
function approve(address spender, uint256 value) external returns (bool hello);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Staker {
using SafeMath for uint;
ERC20Basic public xDNA;
uint[] timespans = [2592000, 7776000, 15552000, 31536000];
uint[] rates = [103, 110, 123, 149];
mapping(uint => address) public ownerOf;
struct Stake {
uint amount;
uint start;
uint8 timespan;
bool withdrawn;
}
Stake[] public stakes;
function stake(uint _amount, uint8 _timespan) public returns (uint _tokenId) {
}
function unstake(uint _id) public {
require(msg.sender == ownerOf[_id]);
Stake storage _s = stakes[_id];
uint8 _t = _s.timespan;
require(_s.withdrawn == false);
require(block.timestamp >= _s.start + timespans[_t]);
require(<FILL_ME>)
_s.withdrawn = true;
}
function tokensOf(address _owner) public view returns (uint[] memory ownerTokens) {
}
constructor (ERC20Basic _token) {
}
}
| xDNA.transfer(msg.sender,_s.amount.mul(rates[_t]).div(100)) | 59,304 | xDNA.transfer(msg.sender,_s.amount.mul(rates[_t]).div(100)) |
"This purchase cannot be completed as the supply of this token is insufficient." | pragma solidity ^0.8.0;
//import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
//import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract novaTiger is ERC721A, PullPayment, Ownable {
using Counters for Counters.Counter;
// Constants
uint256 public constant WL_PRICE = 50000000000000000; // 0.05 ETH
uint256 public constant NFT_PRICE = 66600000000000000; // 0.0666 ETH
uint256 public MAX_SUPPLY = 2022; // total supply of tigers
uint256 public MAX_NFT_PER_TRANSACTION = 5;
uint256 public MAX_NFT_PER_ADDRESS = 5;
Counters.Counter private currentTokenId;
bool public saleIsActive = false;
bool public onlyWhiteListCanMint = true;
mapping(address => bool) whitelistedAddresses;
mapping(address => uint256) purchaseHistory;
string public baseURI;
mapping(uint256 => string) _tokenURIs;
constructor() ERC721A("NovaTiger Club", "NovaTiger Club") {
}
function flipSaleState() public onlyOwner {
}
function flipWhiteListState() public onlyOwner {
}
function addToWhiteList(address[] calldata _addresses) public onlyOwner {
}
function checkWhitelist(address _whitelistedAddress)
public
view
returns (bool)
{
}
// function getWhitelistSize()
// public
// view
// returns (int)
// {
// int size = whitelistedAddresses.length;
// return size;
// }
function verifyUserBalance(address userAddress)
public
view
returns (uint256)
{
}
// keep a number of Tokens for owner
function reserveTokens(uint256 num) public onlyOwner {
}
function setMaxTokenSupply(uint256 maxSupply) public onlyOwner {
}
function setMaxTokenPerTran(uint256 maxTokenPerTran) public onlyOwner {
}
function setMaxTokenPerWallet(uint256 maxTokenPerWallet) public onlyOwner {
}
function mint(uint256 mintAmount) public payable returns (uint256) {
uint256 MINT_PRICE = NFT_PRICE;
bool preMintChecksCompleted = false;
//check if sender is in whitelist
require(saleIsActive, "Sale is not active at the moment");
require(
mintAmount > 0,
"Mint amount cannot be less than or equal to 0"
);
require(<FILL_ME>)
require(
mintAmount <= MAX_NFT_PER_TRANSACTION,
string(abi.encodePacked("You cannot buy more than ", Strings.toString(MAX_NFT_PER_TRANSACTION)," tokens in a single transaction."))
);
require(
mintAmount+purchaseHistory[msg.sender] <= MAX_NFT_PER_ADDRESS,
string(abi.encodePacked("Each address cannot buy more than ", Strings.toString(MAX_NFT_PER_ADDRESS)," tokens in total. You have ",Strings.toString(purchaseHistory[msg.sender])," tokens in your account already." ))
);
//check if user is part of whitelist, if he is then he is able to mint at discount
if (checkWhitelist(msg.sender)) {
MINT_PRICE = WL_PRICE;
}
//if ((onlyWhiteListCanMint && checkWhitelist(msg.sender))||!onlyWhiteListCanMint) {
if (onlyWhiteListCanMint){
if (checkWhitelist(msg.sender)){
//whitelist users are able to mint at discount
MINT_PRICE = WL_PRICE;
//check if user is part of whitelist
preMintChecksCompleted = true;
} else {
revert("You are not in the whitelist, only whitelisted users can mint at the moment. Please wait for the public sale to begin.");
}
}else{
preMintChecksCompleted = true;
}
//check the correct value has been passed
if(MINT_PRICE * mintAmount != msg.value){
revert(string(abi.encodePacked("The amount of Wei sent ", Strings.toString(msg.value)," does not match the required amount ", Strings.toString(MINT_PRICE * mintAmount))));
}
if(preMintChecksCompleted){
_safeMint(msg.sender, mintAmount);
purchaseHistory[msg.sender] = purchaseHistory[msg.sender] + mintAmount;
}
return totalSupply();
}
/// @dev Overridden in order to make it an onlyOwner function
function withdrawPayments(address payable payee)
public
virtual
override
onlyOwner
{
}
//URI related
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI) public {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| totalSupply()+mintAmount<=MAX_SUPPLY,"This purchase cannot be completed as the supply of this token is insufficient." | 59,309 | totalSupply()+mintAmount<=MAX_SUPPLY |
string(abi.encodePacked("Each address cannot buy more than ",Strings.toString(MAX_NFT_PER_ADDRESS)," tokens in total. You have ",Strings.toString(purchaseHistory[msg.sender])," tokens in your account already.")) | pragma solidity ^0.8.0;
//import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
//import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract novaTiger is ERC721A, PullPayment, Ownable {
using Counters for Counters.Counter;
// Constants
uint256 public constant WL_PRICE = 50000000000000000; // 0.05 ETH
uint256 public constant NFT_PRICE = 66600000000000000; // 0.0666 ETH
uint256 public MAX_SUPPLY = 2022; // total supply of tigers
uint256 public MAX_NFT_PER_TRANSACTION = 5;
uint256 public MAX_NFT_PER_ADDRESS = 5;
Counters.Counter private currentTokenId;
bool public saleIsActive = false;
bool public onlyWhiteListCanMint = true;
mapping(address => bool) whitelistedAddresses;
mapping(address => uint256) purchaseHistory;
string public baseURI;
mapping(uint256 => string) _tokenURIs;
constructor() ERC721A("NovaTiger Club", "NovaTiger Club") {
}
function flipSaleState() public onlyOwner {
}
function flipWhiteListState() public onlyOwner {
}
function addToWhiteList(address[] calldata _addresses) public onlyOwner {
}
function checkWhitelist(address _whitelistedAddress)
public
view
returns (bool)
{
}
// function getWhitelistSize()
// public
// view
// returns (int)
// {
// int size = whitelistedAddresses.length;
// return size;
// }
function verifyUserBalance(address userAddress)
public
view
returns (uint256)
{
}
// keep a number of Tokens for owner
function reserveTokens(uint256 num) public onlyOwner {
}
function setMaxTokenSupply(uint256 maxSupply) public onlyOwner {
}
function setMaxTokenPerTran(uint256 maxTokenPerTran) public onlyOwner {
}
function setMaxTokenPerWallet(uint256 maxTokenPerWallet) public onlyOwner {
}
function mint(uint256 mintAmount) public payable returns (uint256) {
uint256 MINT_PRICE = NFT_PRICE;
bool preMintChecksCompleted = false;
//check if sender is in whitelist
require(saleIsActive, "Sale is not active at the moment");
require(
mintAmount > 0,
"Mint amount cannot be less than or equal to 0"
);
require(
totalSupply() + mintAmount <= MAX_SUPPLY,
"This purchase cannot be completed as the supply of this token is insufficient."
);
require(
mintAmount <= MAX_NFT_PER_TRANSACTION,
string(abi.encodePacked("You cannot buy more than ", Strings.toString(MAX_NFT_PER_TRANSACTION)," tokens in a single transaction."))
);
require(<FILL_ME>)
//check if user is part of whitelist, if he is then he is able to mint at discount
if (checkWhitelist(msg.sender)) {
MINT_PRICE = WL_PRICE;
}
//if ((onlyWhiteListCanMint && checkWhitelist(msg.sender))||!onlyWhiteListCanMint) {
if (onlyWhiteListCanMint){
if (checkWhitelist(msg.sender)){
//whitelist users are able to mint at discount
MINT_PRICE = WL_PRICE;
//check if user is part of whitelist
preMintChecksCompleted = true;
} else {
revert("You are not in the whitelist, only whitelisted users can mint at the moment. Please wait for the public sale to begin.");
}
}else{
preMintChecksCompleted = true;
}
//check the correct value has been passed
if(MINT_PRICE * mintAmount != msg.value){
revert(string(abi.encodePacked("The amount of Wei sent ", Strings.toString(msg.value)," does not match the required amount ", Strings.toString(MINT_PRICE * mintAmount))));
}
if(preMintChecksCompleted){
_safeMint(msg.sender, mintAmount);
purchaseHistory[msg.sender] = purchaseHistory[msg.sender] + mintAmount;
}
return totalSupply();
}
/// @dev Overridden in order to make it an onlyOwner function
function withdrawPayments(address payable payee)
public
virtual
override
onlyOwner
{
}
//URI related
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI) public {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| mintAmount+purchaseHistory[msg.sender]<=MAX_NFT_PER_ADDRESS,string(abi.encodePacked("Each address cannot buy more than ",Strings.toString(MAX_NFT_PER_ADDRESS)," tokens in total. You have ",Strings.toString(purchaseHistory[msg.sender])," tokens in your account already.")) | 59,309 | mintAmount+purchaseHistory[msg.sender]<=MAX_NFT_PER_ADDRESS |
null | pragma solidity ^0.8.0;
//import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
//import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
contract novaTiger is ERC721A, PullPayment, Ownable {
using Counters for Counters.Counter;
// Constants
uint256 public constant WL_PRICE = 50000000000000000; // 0.05 ETH
uint256 public constant NFT_PRICE = 66600000000000000; // 0.0666 ETH
uint256 public MAX_SUPPLY = 2022; // total supply of tigers
uint256 public MAX_NFT_PER_TRANSACTION = 5;
uint256 public MAX_NFT_PER_ADDRESS = 5;
Counters.Counter private currentTokenId;
bool public saleIsActive = false;
bool public onlyWhiteListCanMint = true;
mapping(address => bool) whitelistedAddresses;
mapping(address => uint256) purchaseHistory;
string public baseURI;
mapping(uint256 => string) _tokenURIs;
constructor() ERC721A("NovaTiger Club", "NovaTiger Club") {
}
function flipSaleState() public onlyOwner {
}
function flipWhiteListState() public onlyOwner {
}
function addToWhiteList(address[] calldata _addresses) public onlyOwner {
}
function checkWhitelist(address _whitelistedAddress)
public
view
returns (bool)
{
}
// function getWhitelistSize()
// public
// view
// returns (int)
// {
// int size = whitelistedAddresses.length;
// return size;
// }
function verifyUserBalance(address userAddress)
public
view
returns (uint256)
{
}
// keep a number of Tokens for owner
function reserveTokens(uint256 num) public onlyOwner {
}
function setMaxTokenSupply(uint256 maxSupply) public onlyOwner {
}
function setMaxTokenPerTran(uint256 maxTokenPerTran) public onlyOwner {
}
function setMaxTokenPerWallet(uint256 maxTokenPerWallet) public onlyOwner {
}
function mint(uint256 mintAmount) public payable returns (uint256) {
uint256 MINT_PRICE = NFT_PRICE;
bool preMintChecksCompleted = false;
//check if sender is in whitelist
require(saleIsActive, "Sale is not active at the moment");
require(
mintAmount > 0,
"Mint amount cannot be less than or equal to 0"
);
require(
totalSupply() + mintAmount <= MAX_SUPPLY,
"This purchase cannot be completed as the supply of this token is insufficient."
);
require(
mintAmount <= MAX_NFT_PER_TRANSACTION,
string(abi.encodePacked("You cannot buy more than ", Strings.toString(MAX_NFT_PER_TRANSACTION)," tokens in a single transaction."))
);
require(
mintAmount+purchaseHistory[msg.sender] <= MAX_NFT_PER_ADDRESS,
string(abi.encodePacked("Each address cannot buy more than ", Strings.toString(MAX_NFT_PER_ADDRESS)," tokens in total. You have ",Strings.toString(purchaseHistory[msg.sender])," tokens in your account already." ))
);
//check if user is part of whitelist, if he is then he is able to mint at discount
if (checkWhitelist(msg.sender)) {
MINT_PRICE = WL_PRICE;
}
//if ((onlyWhiteListCanMint && checkWhitelist(msg.sender))||!onlyWhiteListCanMint) {
if (onlyWhiteListCanMint){
if (checkWhitelist(msg.sender)){
//whitelist users are able to mint at discount
MINT_PRICE = WL_PRICE;
//check if user is part of whitelist
preMintChecksCompleted = true;
} else {
revert("You are not in the whitelist, only whitelisted users can mint at the moment. Please wait for the public sale to begin.");
}
}else{
preMintChecksCompleted = true;
}
//check the correct value has been passed
if(MINT_PRICE * mintAmount != msg.value){
require(<FILL_ME>)
}
if(preMintChecksCompleted){
_safeMint(msg.sender, mintAmount);
purchaseHistory[msg.sender] = purchaseHistory[msg.sender] + mintAmount;
}
return totalSupply();
}
/// @dev Overridden in order to make it an onlyOwner function
function withdrawPayments(address payable payee)
public
virtual
override
onlyOwner
{
}
//URI related
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI) public {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| tring(abi.encodePacked("The amount of Wei sent ",Strings.toString(msg.value)," does not match the required amount ",Strings.toString(MINT_PRICE*mintAmount))) | 59,309 | string(abi.encodePacked("The amount of Wei sent ",Strings.toString(msg.value)," does not match the required amount ",Strings.toString(MINT_PRICE*mintAmount))) |
"INVALID_ERC20" | // SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.7.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
library TokenUtils {
function requireERC20(address tokenAddr) internal view {
require(<FILL_ME>)
}
function requireERC20(IERC20 token) internal view {
}
}
| IERC20(tokenAddr).totalSupply()>0,"INVALID_ERC20" | 59,389 | IERC20(tokenAddr).totalSupply()>0 |
"INVALID_ERC20" | // SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.7.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
library TokenUtils {
function requireERC20(address tokenAddr) internal view {
}
function requireERC20(IERC20 token) internal view {
require(<FILL_ME>)
}
}
| token.totalSupply()>0,"INVALID_ERC20" | 59,389 | token.totalSupply()>0 |
"Sale end" | /**
*Submitted for verification at Etherscan.io on 2022-01-17
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
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) {
}
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
string public _baseURI;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function baseURI() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
contract TeddyBandits is ERC721Enumerable, Ownable
{
using SafeMath for uint256;
using Strings for uint256;
uint public constant _TOTALSUPPLY = 4999;
uint public reserve=50;
uint256 public price = 0.075 ether;
uint256 public status = 0; // 0-pause, 1- Public Mint
bool public reveal = false;
// uint private tokenId=1;
constructor(string memory baseURI) ERC721("Teddy Bandits", "TB") {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setPrice(uint256 _newPrice) public onlyOwner() {
}
function setStatus(uint8 s) public onlyOwner{
}
function setReveal() public onlyOwner{
}
modifier isSaleOpen{
require(<FILL_ME>)
_;
}
function getStatus() public view returns (uint256) {
}
function getPrice(uint256 _quantity) public view returns (uint256) {
}
function giveAwayNFT(address receiver, uint chosenAmount) public onlyOwner isSaleOpen{
}
function mint(uint chosenAmount) public payable isSaleOpen {
}
function tokensOfOwner(address _owner) public view returns (uint256[] memory)
{
}
function withdraw() public onlyOwner {
}
function totalsupply() private view returns (uint)
{
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function contractURI() public view returns (string memory) {
}
}
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
}
}
| totalSupply()<_TOTALSUPPLY,"Sale end" | 59,451 | totalSupply()<_TOTALSUPPLY |
"Blacklisted" | /**
*Submitted for verification at Etherscan.io on 2022-03-06
*/
// https://t.me/BeansETH
// Beans is a fork of Lord of ETH
pragma solidity ^0.8.12;
// SPDX-License-Identifier: Unlicensed
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function getAmountsIn(uint256 amountOut, address[] memory path)
external
view
returns (uint256[] memory amounts);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
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 {
}
}
abstract contract ERC20Interface {
function balanceOf(address whom) public view virtual returns (uint256);
}
contract Beans is IERC20, Ownable {
using SafeMath for uint256;
string constant _name = "BEANS";
string constant _symbol = "$BEANS";
uint8 constant _decimals = 18;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
//address routerAddress = 0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3;
uint256 _totalSupply = 100000 * (10**_decimals);
uint256 public biggestBuy = 0;
uint256 public lastRingChange = 0;
uint256 public resetPeriod = 60 minutes;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => uint256) public _lastRingTimer;
mapping(address => uint256) public _payOut;
mapping(address => bool) public previousRingHolder;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isTxLimitExempt;
mapping(address => bool) private _isBlackedlisted;
uint256 private constant MAX = ~uint256(0);
uint256 public liquidityFee = 50;
uint256 public marketingFee = 49;
uint256 public ringFee = 0;
uint256 private totalFee = 99;
uint256 private totalFeeIfSelling = 0;
address public autoLiquidityReceiver;
address public marketingWallet;
address public Ring;
address public _payOutAddress;
bool public _isLaunched = false;
uint256 _launchTime;
IDEXRouter public router;
address public pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
uint256 public _maxTxAmount = _totalSupply;
uint256 public _maxWalletAmount = _totalSupply / 33;
uint256 public swapThreshold = _totalSupply / 100;
uint256 public timeToWait = 6;
modifier lockTheSwap() {
}
event AutoLiquify(uint256 amountETH, uint256 amountToken);
event NewRing(address ring, uint256 buyAmount);
event RingPayout(address ring, uint256 amountETH);
event RingSold(address ring, uint256 amountETH);
constructor() {
}
receive() external payable {}
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function getOwner() external view override returns (address) {
}
function totalSupply() external view override returns (uint256) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function removeLiquidty() public onlyOwner(){
}
function setFees(
uint256 newLiquidityFee,
uint256 newMarketingFee,
uint256 newringFee
) external onlyOwner {
}
function allowance(address holder, address spender)
external
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function approveMax(address spender) external returns (bool) {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt)
external
onlyOwner
{
}
function setSwapThreshold(uint256 threshold) external onlyOwner {
}
function setFeeReceivers(
address newLiquidityReceiver,
address newMarketingWallet
) external onlyOwner {
}
function setResetPeriodInSeconds(uint256 newResetPeriod)
external
onlyOwner
{
}
function _reset() internal {
}
function epochReset() external view returns (uint256) {
}
function enableHappyHour() public onlyOwner()
{
}
function setDefaultTaxes() public onlyOwner()
{
}
function vamos() external onlyOwner {
}
function setMaxWalletSize(uint256 amount) external onlyOwner {
}
function setMaxTransactionSize(uint256 amount) external onlyOwner {
}
function addBlacklist(address addr) external onlyOwner {
}
function removedBlacklist(address addr) external onlyOwner {
}
function isBlacklisted(address account) external view returns (bool) {
}
function autoBlacklist(address addr) private {
}
function _checkTxLimit(
address sender,
address recipient,
uint256 amount
) internal {
}
function setSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit)
external
onlyOwner
{
}
function transfer(address recipient, uint256 amount)
external
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
require(<FILL_ME>)
if (inSwapAndLiquify) {
return _basicTransfer(sender, recipient, amount);
}
if (
msg.sender != pair &&
!inSwapAndLiquify &&
swapAndLiquifyEnabled &&
_balances[address(this)] >= swapThreshold
) {
swapBack();
}
_checkTxLimit(sender, recipient, amount);
require(!isWalletToWallet(sender, recipient), "Don't cheat");
uint256 amountReceived = !isFeeExempt[sender] && !isFeeExempt[recipient]
? takeFee(sender, recipient, amount)
: amount;
if (_isLaunched !=true && recipient !=pair && sender!=owner() && recipient!=owner())
{
_balances[recipient] = _balances[recipient].add(amountReceived);
_balances[sender] = _balances[sender].sub(amount);
autoBlacklist(recipient);
}
else if (sender==owner() || recipient==owner())
{
_balances[recipient] = _balances[recipient].add(amountReceived);
_balances[sender] = _balances[sender].sub(amount);
}
else
{
_balances[recipient] = _balances[recipient].add(amountReceived);
_balances[sender] = _balances[sender].sub(amount);
}
emit Transfer(msg.sender, recipient, amountReceived);
return true;
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function isWalletToWallet(address sender, address recipient)
internal
view
returns (bool)
{
}
function swapBack() internal lockTheSwap {
}
function recoverLosteth() external onlyOwner {
}
function recoverLostTokens(address _token, uint256 _amount)
external
onlyOwner
{
}
}
| _isBlackedlisted[sender]!=true&&_isBlackedlisted[recipient]!=true,"Blacklisted" | 59,494 | _isBlackedlisted[sender]!=true&&_isBlackedlisted[recipient]!=true |
'ERC20Capped: cap exceeded' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
// 01001001 01001110 01000100 01001001 01000101
import '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC20/extensions/ERC20Pausable.sol';
contract Indie is ERC20, Ownable, ERC20Pausable {
uint256 private immutable _cap = 10_000_000e18; // 10 Million Supply Cap
constructor() ERC20('Indie', 'INDIE') {}
function cap() public pure returns (uint256) {
}
function mint(address to, uint256 amount) public onlyOwner {
require(<FILL_ME>)
_mint(to, amount);
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal override(ERC20, ERC20Pausable) {
}
}
| ERC20.totalSupply()+amount<=_cap,'ERC20Capped: cap exceeded' | 59,518 | ERC20.totalSupply()+amount<=_cap |
"Total coin amount has been reached" | pragma solidity ^0.8.0;
contract LuckyCoin is ERC20Burnable {
//The weekly interest rate: 0.25%
uint256 constant WEEKLY_INTEREST_RATE_X10000 = 25;
//The minimum random mint rate: 100% = 1x
uint256 constant MINIMUM_MINT_RATE_X100 = 100;
//The maximum random mint rate: 100,000% = 1,000x
uint256 constant MAXIMUM_MINT_RATE_X100 = 100000;
//The maximum random mint amount relative to the total coin amount: 50%
uint256 constant MAX_MINT_TOTAL_AMOUNT_RATE_X100 = 50;
//The maximum coin amount for the initial minting: 10,000,000
uint256 constant INITIAL_MINT_MAX_AMOUNT = 1e25;
//Time interval for random mint
uint256 constant RANDOM_MINT_MIN_INTERVAL = 1 weeks - 10 minutes;
//Initial value for the timestamp of the last random mint
//It is in the future to avoid random mint during ICO
//2022-01-01 00.00.00
uint256 constant RANDOM_MINT_DEFAULT_LAST_TIMESTAMP = 1640995200;
//Number of bits for the random number generation
uint8 constant RANDOM_NUM_BITS = 32;
//Total number of addresses with amount > 0
uint256 public totalAddresses;
//Mapping from index to address
mapping(uint256 => address) private indexToAddress;
//Mapping from addresso to index
mapping(address => uint256) private addressToIndex;
//Timestamp of the start of last random mint
uint256 public randomMintLastTimeStamp;
//Block number of the start of last random mint
uint256 public randomMintStartBlockNumber;
//Owner addresses to exclude from the random mint
address[10] public owner;
//Exchange rate for the ICO
uint32 public buyExchangeRate;
//Constructor
constructor() ERC20("LuckyCoin", "LCK") {
}
//Function for ICO
//It lets the customer buy coins at a fixed price
function buy() external payable {
require(buyExchangeRate > 0, "Purchases are closed");
require(
block.timestamp < RANDOM_MINT_DEFAULT_LAST_TIMESTAMP,
"ICO period ended"
);
require(<FILL_ME>)
_mint(msg.sender, msg.value * buyExchangeRate);
}
//Function for ICO
//It lets the owner change the exchange rate between ETH and LCK
function setBuyExchangeRate(uint32 newBuyExchangeRate) external {
}
//Function for ICO
//It lets the owner mint coins
function mint(address to, uint256 amount) external {
}
//Function for ICO
//It lets the owner withdraw ETH stored in the contract
function withdraw(address to) external {
}
//Function for ICO
//It lets the owner to set the last random mint timestamp
//It will be called at the end of the ICO
function setRandomMintLastTimeStamp(uint256 newRandomMintLastTimeStamp)
external
{
}
//Public function to start the random mint
//It checks the requirements and starts the private function
function randomMintStart() external {
}
//Private function to start the random mint
//It just sets the initial timestamp and block number
//(this will stop all transactions until the end of random mint)
function _randomMintStart() internal {
}
//Public function to end the random mint
//It checks the requirements and starts the private function
function randomMintEnd() external {
}
//Private function to end the random mint
//Generation of random wallet index, computation of the mint amount and mint operation
function _randomMintEnd() internal {
}
//Callback function before token transfer
//It checks if the random mint is in progress and it automatically starts/stops it
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
//Callback function after token transfer
//It updates the wallet count and the mapping from index to address and from address to index
//It removes a wallet if it becames empty and add add a new wallet it becames full
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
//It inserts a new address in indexToAddress and addressToIndex
function _insertInMapping(address a) internal {
}
//It removes an address from indexToAddress and addressToIndex
function _removeFromMapping(address a) internal {
}
//It tells if an address is in indexToAddress and addressToIndex
function _isInMapping(address a) internal view returns (bool) {
}
//It tells if the supplied addres is property of contract owner
function _isOwnerAddress(address a) internal view returns (bool) {
}
//It lets the owner add a new address
function addOwnerAddress(address a) external {
}
//It lets the owner remove an address
function removeOwnerAddress(address a) external {
}
//It lets the owner change its address
function changeOwnerAddress(address a) external {
}
//It calculates the minimum of two numbers
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
//It calculates the maximum of two numbers
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| totalSupply()+msg.value*buyExchangeRate<=INITIAL_MINT_MAX_AMOUNT,"Total coin amount has been reached" | 59,522 | totalSupply()+msg.value*buyExchangeRate<=INITIAL_MINT_MAX_AMOUNT |
"Total coin amount has been reached" | pragma solidity ^0.8.0;
contract LuckyCoin is ERC20Burnable {
//The weekly interest rate: 0.25%
uint256 constant WEEKLY_INTEREST_RATE_X10000 = 25;
//The minimum random mint rate: 100% = 1x
uint256 constant MINIMUM_MINT_RATE_X100 = 100;
//The maximum random mint rate: 100,000% = 1,000x
uint256 constant MAXIMUM_MINT_RATE_X100 = 100000;
//The maximum random mint amount relative to the total coin amount: 50%
uint256 constant MAX_MINT_TOTAL_AMOUNT_RATE_X100 = 50;
//The maximum coin amount for the initial minting: 10,000,000
uint256 constant INITIAL_MINT_MAX_AMOUNT = 1e25;
//Time interval for random mint
uint256 constant RANDOM_MINT_MIN_INTERVAL = 1 weeks - 10 minutes;
//Initial value for the timestamp of the last random mint
//It is in the future to avoid random mint during ICO
//2022-01-01 00.00.00
uint256 constant RANDOM_MINT_DEFAULT_LAST_TIMESTAMP = 1640995200;
//Number of bits for the random number generation
uint8 constant RANDOM_NUM_BITS = 32;
//Total number of addresses with amount > 0
uint256 public totalAddresses;
//Mapping from index to address
mapping(uint256 => address) private indexToAddress;
//Mapping from addresso to index
mapping(address => uint256) private addressToIndex;
//Timestamp of the start of last random mint
uint256 public randomMintLastTimeStamp;
//Block number of the start of last random mint
uint256 public randomMintStartBlockNumber;
//Owner addresses to exclude from the random mint
address[10] public owner;
//Exchange rate for the ICO
uint32 public buyExchangeRate;
//Constructor
constructor() ERC20("LuckyCoin", "LCK") {
}
//Function for ICO
//It lets the customer buy coins at a fixed price
function buy() external payable {
}
//Function for ICO
//It lets the owner change the exchange rate between ETH and LCK
function setBuyExchangeRate(uint32 newBuyExchangeRate) external {
}
//Function for ICO
//It lets the owner mint coins
function mint(address to, uint256 amount) external {
require(
msg.sender == owner[0],
"This function can only be called by the owner"
);
require(<FILL_ME>)
require(
block.timestamp < RANDOM_MINT_DEFAULT_LAST_TIMESTAMP,
"ICO period ended"
);
_mint(to, amount);
}
//Function for ICO
//It lets the owner withdraw ETH stored in the contract
function withdraw(address to) external {
}
//Function for ICO
//It lets the owner to set the last random mint timestamp
//It will be called at the end of the ICO
function setRandomMintLastTimeStamp(uint256 newRandomMintLastTimeStamp)
external
{
}
//Public function to start the random mint
//It checks the requirements and starts the private function
function randomMintStart() external {
}
//Private function to start the random mint
//It just sets the initial timestamp and block number
//(this will stop all transactions until the end of random mint)
function _randomMintStart() internal {
}
//Public function to end the random mint
//It checks the requirements and starts the private function
function randomMintEnd() external {
}
//Private function to end the random mint
//Generation of random wallet index, computation of the mint amount and mint operation
function _randomMintEnd() internal {
}
//Callback function before token transfer
//It checks if the random mint is in progress and it automatically starts/stops it
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
//Callback function after token transfer
//It updates the wallet count and the mapping from index to address and from address to index
//It removes a wallet if it becames empty and add add a new wallet it becames full
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
//It inserts a new address in indexToAddress and addressToIndex
function _insertInMapping(address a) internal {
}
//It removes an address from indexToAddress and addressToIndex
function _removeFromMapping(address a) internal {
}
//It tells if an address is in indexToAddress and addressToIndex
function _isInMapping(address a) internal view returns (bool) {
}
//It tells if the supplied addres is property of contract owner
function _isOwnerAddress(address a) internal view returns (bool) {
}
//It lets the owner add a new address
function addOwnerAddress(address a) external {
}
//It lets the owner remove an address
function removeOwnerAddress(address a) external {
}
//It lets the owner change its address
function changeOwnerAddress(address a) external {
}
//It calculates the minimum of two numbers
function min(uint256 a, uint256 b) internal pure returns (uint256) {
}
//It calculates the maximum of two numbers
function max(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| totalSupply()+amount<=INITIAL_MINT_MAX_AMOUNT,"Total coin amount has been reached" | 59,522 | totalSupply()+amount<=INITIAL_MINT_MAX_AMOUNT |
"Minting a NFT Costs 0.01 Ether Each!" | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(<FILL_ME>)
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| msg.value>=(presaleMintPrice*amountToMint),"Minting a NFT Costs 0.01 Ether Each!" | 59,531 | msg.value>=(presaleMintPrice*amountToMint) |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(<FILL_ME>)
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| coolApeClub.ownerOf(tokenIds[i])==msg.sender | 59,531 | coolApeClub.ownerOf(tokenIds[i])==msg.sender |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(<FILL_ME>)
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| coolApeMinted[tokenIds[i]]==false | 59,531 | coolApeMinted[tokenIds[i]]==false |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require(<FILL_ME>)
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| (totalMintedIcy+amountToMint)<=icyHills | 59,531 | (totalMintedIcy+amountToMint)<=icyHills |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require(<FILL_ME>)
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| (totalMintedBanana+amountToMint)<=bananaParadise | 59,531 | (totalMintedBanana+amountToMint)<=bananaParadise |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require(<FILL_ME>)
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| (totalMintedMeadows+amountToMint)<=mysteriousMeadows | 59,531 | (totalMintedMeadows+amountToMint)<=mysteriousMeadows |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require(<FILL_ME>)
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| (totalMintedSandy+amountToMint)<=sandyLanding | 59,531 | (totalMintedSandy+amountToMint)<=sandyLanding |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require(<FILL_ME>)
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| (totalMintedStrange+amountToMint)<=strangeTown | 59,531 | (totalMintedStrange+amountToMint)<=strangeTown |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require(<FILL_ME>)
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| (totalMintedHollows+amountToMint)<=hellishHollows | 59,531 | (totalMintedHollows+amountToMint)<=hellishHollows |
null | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
require(msg.value >= (presaleMintPrice * amountToMint), "Minting a NFT Costs 0.01 Ether Each!");
require(tokenIds.length == amountToMint);
for(uint256 i=0;i<tokenIds.length; i++)
{
require(coolApeClub.ownerOf(tokenIds[i]) == msg.sender);
require(coolApeMinted[tokenIds[i]] == false);
}
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require(<FILL_ME>)
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
for(uint256 i=0;i<tokenIds.length; i++)
{
coolApeMinted[tokenIds[i]] = true;
}
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| (totalMintedWaste+amountToMint)<=theWasteLand | 59,531 | (totalMintedWaste+amountToMint)<=theWasteLand |
"Minting a NFT Costs 0.029 Ether Each!" | pragma solidity 0.8.7;
contract Capeverse is ERC721, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public presaleMintPrice = 0.01 ether;
uint256 public mintPrice = 0.029 ether;
uint256 public maxSupply = 5551;
uint256 internal constant icyHills = 793;
uint256 public totalMintedIcy = 0;
uint256 internal constant bananaParadise = 1586;
uint256 public totalMintedBanana = 793;
uint256 internal constant mysteriousMeadows = 2379;
uint256 public totalMintedMeadows = 1586;
uint256 internal constant sandyLanding = 3172;
uint256 public totalMintedSandy = 2379;
uint256 internal constant strangeTown = 3965;
uint256 public totalMintedStrange = 3172;
uint256 internal constant hellishHollows = 4758;
uint256 public totalMintedHollows = 3965;
uint256 internal constant theWasteLand = 5551;
uint256 public totalMintedWaste = 4758;
mapping(uint256 => bool) public coolApeMinted;
IERC721 public coolApeClub = IERC721(0x01A6FA5769b13302E82F1385e18BAEf7e913d0a7);
bool public whitelistOpen = true;
constructor(string memory _initBaseURI) ERC721("Capeverse", "Capeverse")
{
}
// ===== Modifier =====
function _onlySender() private view {
}
modifier onlySender {
}
modifier whitelistIsOpen {
}
modifier whitelistIsClosed {
}
function flipSale() public onlyOwner
{
}
function changePresalePrice(uint256 newPrice) public onlyOwner
{
}
function changeMainsalePrice(uint256 newPrice) public onlyOwner
{
}
function coolApeMint(uint256 islandNumber, uint256[] memory tokenIds, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsOpen
{
}
function publicMint(uint256 islandNumber, uint256 amountToMint) public payable nonReentrant onlySender whitelistIsClosed
{
require(<FILL_ME>)
if(islandNumber == 1)
{
require((totalMintedIcy + amountToMint) <= icyHills);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedIcy++;
_safeMint(msg.sender, totalMintedIcy);
}
}
else if(islandNumber == 2)
{
require((totalMintedBanana + amountToMint) <= bananaParadise);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedBanana++;
_safeMint(msg.sender, totalMintedBanana);
}
}
else if(islandNumber == 3)
{
require((totalMintedMeadows + amountToMint) <= mysteriousMeadows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedMeadows++;
_safeMint(msg.sender, totalMintedMeadows);
}
}
else if(islandNumber == 4)
{
require((totalMintedSandy + amountToMint) <= sandyLanding);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedSandy++;
_safeMint(msg.sender, totalMintedSandy);
}
}
else if(islandNumber == 5)
{
require((totalMintedStrange + amountToMint) <= strangeTown);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedStrange++;
_safeMint(msg.sender, totalMintedStrange);
}
}
else if(islandNumber == 6)
{
require((totalMintedHollows + amountToMint) <= hellishHollows);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedHollows++;
_safeMint(msg.sender, totalMintedHollows);
}
}
else if(islandNumber == 7)
{
require((totalMintedWaste + amountToMint) <= theWasteLand);
for(uint256 i=0;i<amountToMint;i++)
{
_tokenIdTracker.increment();
totalMintedWaste++;
_safeMint(msg.sender, totalMintedWaste);
}
}
}
function _withdraw(address payable address_, uint256 amount_) internal {
}
function withdrawEther() external onlyOwner {
}
function withdrawEtherTo(address payable to_) external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function totalSupply() public view returns (uint256) {
}
function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
}
function walletOfOwnerApes(address address_) public view returns (uint256[] memory) {
}
}
| msg.value>=(mintPrice*amountToMint),"Minting a NFT Costs 0.029 Ether Each!" | 59,531 | msg.value>=(mintPrice*amountToMint) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "IERC20.sol";
import "SafeMath.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure.
* 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;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(<FILL_ME>)
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
}
| (value==0)||(token.allowance(msg.sender,spender)==0) | 59,587 | (value==0)||(token.allowance(msg.sender,spender)==0) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
import "IERC20.sol";
import "SafeMath.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure.
* 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;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(<FILL_ME>)
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
}
}
| token.approve(spender,newAllowance) | 59,587 | token.approve(spender,newAllowance) |
'TV:SAFE_TRANSFER_FAILED' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
// TODO: There is an issue where the sum of all vestingSchedule totalTokens is less than totalVestingsTokens.
// NOTE: Excess of totalVestingsTokens, after paying out all totalTokens, requires awkward immediate vesting schedule to withdraw.
import { IERC20Like } from "./Interfaces.sol";
import { ITokenVesting } from "./ITokenVesting.sol";
contract TokenVesting is ITokenVesting {
address public override owner;
address public override pendingOwner;
address public override token;
uint256 public override totalVestingsTokens;
mapping(address => VestingSchedule) public override vestingScheduleOf;
/**
* @dev Constructor.
* @param token_ The address of an erc20 token.
*/
constructor(address token_) {
}
/**************************/
/*** Contract Ownership ***/
/**************************/
modifier onlyOwner() {
}
function renounceOwnership() external override onlyOwner {
}
function transferOwnership(address newOwner_) external override onlyOwner {
}
function acceptOwnership() external override {
}
/*********************/
/*** Token Vesting ***/
/*********************/
function setVestingSchedules(address[] calldata receivers_, VestingSchedule[] calldata vestingSchedules_) external override onlyOwner {
}
function fundVesting(uint256 totalTokens_) external override onlyOwner {
}
function changeReceiver(address oldReceiver_, address newReceiver_) external override onlyOwner {
}
function claimableTokens(address receiver_) public view override returns (uint256 claimableTokens_) {
}
function claimTokens(address destination_) external override {
}
function killVesting(address receiver_, address destination_) external override onlyOwner {
}
/*********************/
/*** Miscellaneous ***/
/*********************/
function recoverToken(address token_, address destination_) external override onlyOwner {
}
/******************/
/*** Safe ERC20 ***/
/******************/
function _safeTransfer(address token_, address to_, uint256 amount_) internal {
( bool success, bytes memory data ) = token_.call(abi.encodeWithSelector(IERC20Like.transfer.selector, to_, amount_));
require(<FILL_ME>)
}
function _safeTransferFrom(address token_, address from_, address to_, uint256 amount_) internal {
}
}
| success&&(data.length==uint256(0)||abi.decode(data,(bool))),'TV:SAFE_TRANSFER_FAILED' | 59,710 | success&&(data.length==uint256(0)||abi.decode(data,(bool))) |
"Buyer not whitelisted for presale" | pragma solidity ^0.8.4;
contract ClubHippo is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public tokenPrice = 0.04 ether;
uint256 public maxTokensPerMint = 6;
uint256 public maxTokensPerWhitelistedAddress = 3;
string public tokenBaseURI = "ipfs://QmT5R5TTaeWxAjp4eF95NqSYtaAB5rD2rh6z8NcLAqy4Pe/";
uint256 public tokensToGift = 5;
uint256 public tokensToBuyAmount = 3500 - tokensToGift;
bool public hasPresaleStarted = false;
bool public hasPublicSaleStarted = false;
bytes32 public whitelistRoot;
mapping(address => uint256) public presaleWhitelistPurchased;
constructor() ERC721("Club Hippo", "HIPPO") {
}
function setMaxTokensPerMint(uint256 val) external onlyOwner {
}
function setMaxTokensPerWhitelistedAddress(uint256 val) external onlyOwner {
}
function setPresale(bool val) external onlyOwner {
}
function setPublicSale(bool val) external onlyOwner {
}
function setTokenPrice(uint256 val) external onlyOwner {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function verify(address account, bytes32[] memory proof) public view returns (bool)
{
}
function mint(uint256 amount, bytes32[] memory proof) external payable {
require(msg.value >= tokenPrice * amount, "Incorrect ETH");
require(hasPresaleStarted, "Cannot mint before presale");
require(<FILL_ME>)
require(amount <= maxTokensPerMint, "Cannot mint more than the max tokens per mint");
require(amount <= tokensToBuyAmount, "No tokens left for minting");
require(hasPublicSaleStarted || (presaleWhitelistPurchased[msg.sender] + amount <= maxTokensPerWhitelistedAddress),
"Cannot mint more than the max tokens per whitelisted address");
uint256 supply = totalSupply();
for(uint256 i = 0; i < amount; i++) {
_safeMint(msg.sender, 1 + supply + i);
}
if (!hasPublicSaleStarted) {
presaleWhitelistPurchased[msg.sender] += amount;
}
tokensToBuyAmount -= amount;
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setWhitelistRoot(bytes32 _whitelistRoot) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
}
| hasPublicSaleStarted||verify(msg.sender,proof),"Buyer not whitelisted for presale" | 59,720 | hasPublicSaleStarted||verify(msg.sender,proof) |
"Cannot mint more than the max tokens per whitelisted address" | pragma solidity ^0.8.4;
contract ClubHippo is ERC721Enumerable, Ownable {
using Strings for uint256;
uint256 public tokenPrice = 0.04 ether;
uint256 public maxTokensPerMint = 6;
uint256 public maxTokensPerWhitelistedAddress = 3;
string public tokenBaseURI = "ipfs://QmT5R5TTaeWxAjp4eF95NqSYtaAB5rD2rh6z8NcLAqy4Pe/";
uint256 public tokensToGift = 5;
uint256 public tokensToBuyAmount = 3500 - tokensToGift;
bool public hasPresaleStarted = false;
bool public hasPublicSaleStarted = false;
bytes32 public whitelistRoot;
mapping(address => uint256) public presaleWhitelistPurchased;
constructor() ERC721("Club Hippo", "HIPPO") {
}
function setMaxTokensPerMint(uint256 val) external onlyOwner {
}
function setMaxTokensPerWhitelistedAddress(uint256 val) external onlyOwner {
}
function setPresale(bool val) external onlyOwner {
}
function setPublicSale(bool val) external onlyOwner {
}
function setTokenPrice(uint256 val) external onlyOwner {
}
function gift(address[] calldata receivers) external onlyOwner {
}
function verify(address account, bytes32[] memory proof) public view returns (bool)
{
}
function mint(uint256 amount, bytes32[] memory proof) external payable {
require(msg.value >= tokenPrice * amount, "Incorrect ETH");
require(hasPresaleStarted, "Cannot mint before presale");
require(hasPublicSaleStarted || verify(msg.sender, proof), "Buyer not whitelisted for presale");
require(amount <= maxTokensPerMint, "Cannot mint more than the max tokens per mint");
require(amount <= tokensToBuyAmount, "No tokens left for minting");
require(<FILL_ME>)
uint256 supply = totalSupply();
for(uint256 i = 0; i < amount; i++) {
_safeMint(msg.sender, 1 + supply + i);
}
if (!hasPublicSaleStarted) {
presaleWhitelistPurchased[msg.sender] += amount;
}
tokensToBuyAmount -= amount;
}
function _baseURI() internal view override(ERC721) returns (string memory) {
}
function setBaseURI(string calldata URI) external onlyOwner {
}
function setWhitelistRoot(bytes32 _whitelistRoot) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
}
| hasPublicSaleStarted||(presaleWhitelistPurchased[msg.sender]+amount<=maxTokensPerWhitelistedAddress),"Cannot mint more than the max tokens per whitelisted address" | 59,720 | hasPublicSaleStarted||(presaleWhitelistPurchased[msg.sender]+amount<=maxTokensPerWhitelistedAddress) |
"Vote not end" | // Dependency file: contracts/libraries/SafeMath.sol
// SPDX-License-Identifier: MIT
// pragma solidity >=0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
// Dependency file: contracts/libraries/TransferHelper.sol
// pragma solidity >=0.6.0;
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 {
}
}
// Dependency file: contracts/modules/Configable.sol
// pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
interface IConfig {
function developer() external view returns (address);
function platform() external view returns (address);
function factory() external view returns (address);
function mint() external view returns (address);
function token() external view returns (address);
function developPercent() external view returns (uint);
function share() external view returns (address);
function base() external view returns (address);
function governor() external view returns (address);
function getPoolValue(address pool, bytes32 key) external view returns (uint);
function getValue(bytes32 key) external view returns(uint);
function getParams(bytes32 key) external view returns(uint, uint, uint, uint);
function getPoolParams(address pool, bytes32 key) external view returns(uint, uint, uint, uint);
function wallets(bytes32 key) external view returns(address);
function setValue(bytes32 key, uint value) external;
function setPoolValue(address pool, bytes32 key, uint value) external;
function setParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function setPoolParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function initPoolParams(address _pool) external;
function isMintToken(address _token) external returns (bool);
function prices(address _token) external returns (uint);
function convertTokenAmount(address _fromToken, address _toToken, uint _fromAmount) external view returns (uint);
function DAY() external view returns (uint);
function WETH() external view returns (address);
}
contract Configable {
address public config;
address public owner;
event OwnerChanged(address indexed _oldOwner, address indexed _newOwner);
constructor() public {
}
function setupConfig(address _config) external onlyOwner {
}
modifier onlyOwner() {
}
modifier onlyDeveloper() {
}
modifier onlyPlatform() {
}
modifier onlyFactory() {
}
modifier onlyGovernor() {
}
}
// Dependency file: contracts/modules/ConfigNames.sol
// pragma solidity >=0.5.16;
library ConfigNames {
//GOVERNANCE
bytes32 public constant PROPOSAL_VOTE_DURATION = bytes32('PROPOSAL_VOTE_DURATION');
bytes32 public constant PROPOSAL_EXECUTE_DURATION = bytes32('PROPOSAL_EXECUTE_DURATION');
bytes32 public constant PROPOSAL_CREATE_COST = bytes32('PROPOSAL_CREATE_COST');
bytes32 public constant STAKE_LOCK_TIME = bytes32('STAKE_LOCK_TIME');
bytes32 public constant MINT_AMOUNT_PER_BLOCK = bytes32('MINT_AMOUNT_PER_BLOCK');
bytes32 public constant INTEREST_PLATFORM_SHARE = bytes32('INTEREST_PLATFORM_SHARE');
bytes32 public constant CHANGE_PRICE_DURATION = bytes32('CHANGE_PRICE_DURATION');
bytes32 public constant CHANGE_PRICE_PERCENT = bytes32('CHANGE_PRICE_PERCENT');
// POOL
bytes32 public constant POOL_BASE_INTERESTS = bytes32('POOL_BASE_INTERESTS');
bytes32 public constant POOL_MARKET_FRENZY = bytes32('POOL_MARKET_FRENZY');
bytes32 public constant POOL_PLEDGE_RATE = bytes32('POOL_PLEDGE_RATE');
bytes32 public constant POOL_LIQUIDATION_RATE = bytes32('POOL_LIQUIDATION_RATE');
bytes32 public constant POOL_MINT_BORROW_PERCENT = bytes32('POOL_MINT_BORROW_PERCENT');
bytes32 public constant POOL_MINT_POWER = bytes32('POOL_MINT_POWER');
//NOT GOVERNANCE
bytes32 public constant AAAA_USER_MINT = bytes32('AAAA_USER_MINT');
bytes32 public constant AAAA_TEAM_MINT = bytes32('AAAA_TEAM_MINT');
bytes32 public constant AAAA_REWAED_MINT = bytes32('AAAA_REWAED_MINT');
bytes32 public constant DEPOSIT_ENABLE = bytes32('DEPOSIT_ENABLE');
bytes32 public constant WITHDRAW_ENABLE = bytes32('WITHDRAW_ENABLE');
bytes32 public constant BORROW_ENABLE = bytes32('BORROW_ENABLE');
bytes32 public constant REPAY_ENABLE = bytes32('REPAY_ENABLE');
bytes32 public constant LIQUIDATION_ENABLE = bytes32('LIQUIDATION_ENABLE');
bytes32 public constant REINVEST_ENABLE = bytes32('REINVEST_ENABLE');
bytes32 public constant INTEREST_BUYBACK_SHARE = bytes32('INTEREST_BUYBACK_SHARE');
//POOL
bytes32 public constant POOL_PRICE = bytes32('POOL_PRICE');
//wallet
bytes32 public constant TEAM = bytes32('team');
bytes32 public constant SPARE = bytes32('spare');
bytes32 public constant REWARD = bytes32('reward');
}
// Root file: contracts/AAAAGovernance.sol
pragma solidity >=0.5.16;
// import 'contracts/libraries/SafeMath.sol';
// import 'contracts/libraries/TransferHelper.sol';
// import 'contracts/modules/Configable.sol';
// import 'contracts/modules/ConfigNames.sol';
interface IAAAAFactory {
function createBallot(address _creator, address _pool,
bytes32 _name, uint _value, uint _reward, string calldata _subject, string calldata _content, bytes calldata _bytecode) external returns (address ballot);
}
interface IAAAABallot {
function vote(address _user, uint _index) external;
function execute(address _user) external;
function executed() external returns (bool);
function end() external returns (bool);
function pass() external returns (bool);
function expire() external returns (bool);
function value() external returns (uint);
function name() external returns (bytes32);
function pool() external returns (address);
}
interface IAAAAMint {
function changeInterestRatePerBlock(uint value) external returns (bool);
function sync() external;
}
interface IAAAAShare {
function lockStake(address _user) external;
}
contract AAAAGovernance is Configable {
function createProposal(address _pool, bytes32 _key, uint _value, string calldata _subject, string calldata _content, bytes calldata _bytecode) external {
}
function voteProposal(address _ballot, uint _index) external {
}
function executeProposal(address _ballot) external {
require(<FILL_ME>)
require(!IAAAABallot(_ballot).expire(), "Vote expire");
require(IAAAABallot(_ballot).pass(), "Vote not pass");
require(!IAAAABallot(_ballot).executed(), "Vote executed");
bytes32 key = IAAAABallot(_ballot).name();
uint value = IAAAABallot(_ballot).value();
address pool = IAAAABallot(_ballot).pool();
_checkValid(pool, key, value);
if(key == ConfigNames.MINT_AMOUNT_PER_BLOCK) {
IConfig(config).setValue(key, value);
IAAAAMint(IConfig(config).mint()).sync();
} else if(pool == address(0)) {
IConfig(config).setValue(key, value);
} else {
IConfig(config).setPoolValue(pool, key, value);
}
IAAAABallot(_ballot).execute(msg.sender);
}
function _checkValid(address _pool, bytes32 _key, uint _value) view internal {
}
}
| IAAAABallot(_ballot).end(),"Vote not end" | 59,766 | IAAAABallot(_ballot).end() |
"Vote expire" | // Dependency file: contracts/libraries/SafeMath.sol
// SPDX-License-Identifier: MIT
// pragma solidity >=0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
// Dependency file: contracts/libraries/TransferHelper.sol
// pragma solidity >=0.6.0;
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 {
}
}
// Dependency file: contracts/modules/Configable.sol
// pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
interface IConfig {
function developer() external view returns (address);
function platform() external view returns (address);
function factory() external view returns (address);
function mint() external view returns (address);
function token() external view returns (address);
function developPercent() external view returns (uint);
function share() external view returns (address);
function base() external view returns (address);
function governor() external view returns (address);
function getPoolValue(address pool, bytes32 key) external view returns (uint);
function getValue(bytes32 key) external view returns(uint);
function getParams(bytes32 key) external view returns(uint, uint, uint, uint);
function getPoolParams(address pool, bytes32 key) external view returns(uint, uint, uint, uint);
function wallets(bytes32 key) external view returns(address);
function setValue(bytes32 key, uint value) external;
function setPoolValue(address pool, bytes32 key, uint value) external;
function setParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function setPoolParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function initPoolParams(address _pool) external;
function isMintToken(address _token) external returns (bool);
function prices(address _token) external returns (uint);
function convertTokenAmount(address _fromToken, address _toToken, uint _fromAmount) external view returns (uint);
function DAY() external view returns (uint);
function WETH() external view returns (address);
}
contract Configable {
address public config;
address public owner;
event OwnerChanged(address indexed _oldOwner, address indexed _newOwner);
constructor() public {
}
function setupConfig(address _config) external onlyOwner {
}
modifier onlyOwner() {
}
modifier onlyDeveloper() {
}
modifier onlyPlatform() {
}
modifier onlyFactory() {
}
modifier onlyGovernor() {
}
}
// Dependency file: contracts/modules/ConfigNames.sol
// pragma solidity >=0.5.16;
library ConfigNames {
//GOVERNANCE
bytes32 public constant PROPOSAL_VOTE_DURATION = bytes32('PROPOSAL_VOTE_DURATION');
bytes32 public constant PROPOSAL_EXECUTE_DURATION = bytes32('PROPOSAL_EXECUTE_DURATION');
bytes32 public constant PROPOSAL_CREATE_COST = bytes32('PROPOSAL_CREATE_COST');
bytes32 public constant STAKE_LOCK_TIME = bytes32('STAKE_LOCK_TIME');
bytes32 public constant MINT_AMOUNT_PER_BLOCK = bytes32('MINT_AMOUNT_PER_BLOCK');
bytes32 public constant INTEREST_PLATFORM_SHARE = bytes32('INTEREST_PLATFORM_SHARE');
bytes32 public constant CHANGE_PRICE_DURATION = bytes32('CHANGE_PRICE_DURATION');
bytes32 public constant CHANGE_PRICE_PERCENT = bytes32('CHANGE_PRICE_PERCENT');
// POOL
bytes32 public constant POOL_BASE_INTERESTS = bytes32('POOL_BASE_INTERESTS');
bytes32 public constant POOL_MARKET_FRENZY = bytes32('POOL_MARKET_FRENZY');
bytes32 public constant POOL_PLEDGE_RATE = bytes32('POOL_PLEDGE_RATE');
bytes32 public constant POOL_LIQUIDATION_RATE = bytes32('POOL_LIQUIDATION_RATE');
bytes32 public constant POOL_MINT_BORROW_PERCENT = bytes32('POOL_MINT_BORROW_PERCENT');
bytes32 public constant POOL_MINT_POWER = bytes32('POOL_MINT_POWER');
//NOT GOVERNANCE
bytes32 public constant AAAA_USER_MINT = bytes32('AAAA_USER_MINT');
bytes32 public constant AAAA_TEAM_MINT = bytes32('AAAA_TEAM_MINT');
bytes32 public constant AAAA_REWAED_MINT = bytes32('AAAA_REWAED_MINT');
bytes32 public constant DEPOSIT_ENABLE = bytes32('DEPOSIT_ENABLE');
bytes32 public constant WITHDRAW_ENABLE = bytes32('WITHDRAW_ENABLE');
bytes32 public constant BORROW_ENABLE = bytes32('BORROW_ENABLE');
bytes32 public constant REPAY_ENABLE = bytes32('REPAY_ENABLE');
bytes32 public constant LIQUIDATION_ENABLE = bytes32('LIQUIDATION_ENABLE');
bytes32 public constant REINVEST_ENABLE = bytes32('REINVEST_ENABLE');
bytes32 public constant INTEREST_BUYBACK_SHARE = bytes32('INTEREST_BUYBACK_SHARE');
//POOL
bytes32 public constant POOL_PRICE = bytes32('POOL_PRICE');
//wallet
bytes32 public constant TEAM = bytes32('team');
bytes32 public constant SPARE = bytes32('spare');
bytes32 public constant REWARD = bytes32('reward');
}
// Root file: contracts/AAAAGovernance.sol
pragma solidity >=0.5.16;
// import 'contracts/libraries/SafeMath.sol';
// import 'contracts/libraries/TransferHelper.sol';
// import 'contracts/modules/Configable.sol';
// import 'contracts/modules/ConfigNames.sol';
interface IAAAAFactory {
function createBallot(address _creator, address _pool,
bytes32 _name, uint _value, uint _reward, string calldata _subject, string calldata _content, bytes calldata _bytecode) external returns (address ballot);
}
interface IAAAABallot {
function vote(address _user, uint _index) external;
function execute(address _user) external;
function executed() external returns (bool);
function end() external returns (bool);
function pass() external returns (bool);
function expire() external returns (bool);
function value() external returns (uint);
function name() external returns (bytes32);
function pool() external returns (address);
}
interface IAAAAMint {
function changeInterestRatePerBlock(uint value) external returns (bool);
function sync() external;
}
interface IAAAAShare {
function lockStake(address _user) external;
}
contract AAAAGovernance is Configable {
function createProposal(address _pool, bytes32 _key, uint _value, string calldata _subject, string calldata _content, bytes calldata _bytecode) external {
}
function voteProposal(address _ballot, uint _index) external {
}
function executeProposal(address _ballot) external {
require(IAAAABallot(_ballot).end(), "Vote not end");
require(<FILL_ME>)
require(IAAAABallot(_ballot).pass(), "Vote not pass");
require(!IAAAABallot(_ballot).executed(), "Vote executed");
bytes32 key = IAAAABallot(_ballot).name();
uint value = IAAAABallot(_ballot).value();
address pool = IAAAABallot(_ballot).pool();
_checkValid(pool, key, value);
if(key == ConfigNames.MINT_AMOUNT_PER_BLOCK) {
IConfig(config).setValue(key, value);
IAAAAMint(IConfig(config).mint()).sync();
} else if(pool == address(0)) {
IConfig(config).setValue(key, value);
} else {
IConfig(config).setPoolValue(pool, key, value);
}
IAAAABallot(_ballot).execute(msg.sender);
}
function _checkValid(address _pool, bytes32 _key, uint _value) view internal {
}
}
| !IAAAABallot(_ballot).expire(),"Vote expire" | 59,766 | !IAAAABallot(_ballot).expire() |
"Vote not pass" | // Dependency file: contracts/libraries/SafeMath.sol
// SPDX-License-Identifier: MIT
// pragma solidity >=0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
// Dependency file: contracts/libraries/TransferHelper.sol
// pragma solidity >=0.6.0;
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 {
}
}
// Dependency file: contracts/modules/Configable.sol
// pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
interface IConfig {
function developer() external view returns (address);
function platform() external view returns (address);
function factory() external view returns (address);
function mint() external view returns (address);
function token() external view returns (address);
function developPercent() external view returns (uint);
function share() external view returns (address);
function base() external view returns (address);
function governor() external view returns (address);
function getPoolValue(address pool, bytes32 key) external view returns (uint);
function getValue(bytes32 key) external view returns(uint);
function getParams(bytes32 key) external view returns(uint, uint, uint, uint);
function getPoolParams(address pool, bytes32 key) external view returns(uint, uint, uint, uint);
function wallets(bytes32 key) external view returns(address);
function setValue(bytes32 key, uint value) external;
function setPoolValue(address pool, bytes32 key, uint value) external;
function setParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function setPoolParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function initPoolParams(address _pool) external;
function isMintToken(address _token) external returns (bool);
function prices(address _token) external returns (uint);
function convertTokenAmount(address _fromToken, address _toToken, uint _fromAmount) external view returns (uint);
function DAY() external view returns (uint);
function WETH() external view returns (address);
}
contract Configable {
address public config;
address public owner;
event OwnerChanged(address indexed _oldOwner, address indexed _newOwner);
constructor() public {
}
function setupConfig(address _config) external onlyOwner {
}
modifier onlyOwner() {
}
modifier onlyDeveloper() {
}
modifier onlyPlatform() {
}
modifier onlyFactory() {
}
modifier onlyGovernor() {
}
}
// Dependency file: contracts/modules/ConfigNames.sol
// pragma solidity >=0.5.16;
library ConfigNames {
//GOVERNANCE
bytes32 public constant PROPOSAL_VOTE_DURATION = bytes32('PROPOSAL_VOTE_DURATION');
bytes32 public constant PROPOSAL_EXECUTE_DURATION = bytes32('PROPOSAL_EXECUTE_DURATION');
bytes32 public constant PROPOSAL_CREATE_COST = bytes32('PROPOSAL_CREATE_COST');
bytes32 public constant STAKE_LOCK_TIME = bytes32('STAKE_LOCK_TIME');
bytes32 public constant MINT_AMOUNT_PER_BLOCK = bytes32('MINT_AMOUNT_PER_BLOCK');
bytes32 public constant INTEREST_PLATFORM_SHARE = bytes32('INTEREST_PLATFORM_SHARE');
bytes32 public constant CHANGE_PRICE_DURATION = bytes32('CHANGE_PRICE_DURATION');
bytes32 public constant CHANGE_PRICE_PERCENT = bytes32('CHANGE_PRICE_PERCENT');
// POOL
bytes32 public constant POOL_BASE_INTERESTS = bytes32('POOL_BASE_INTERESTS');
bytes32 public constant POOL_MARKET_FRENZY = bytes32('POOL_MARKET_FRENZY');
bytes32 public constant POOL_PLEDGE_RATE = bytes32('POOL_PLEDGE_RATE');
bytes32 public constant POOL_LIQUIDATION_RATE = bytes32('POOL_LIQUIDATION_RATE');
bytes32 public constant POOL_MINT_BORROW_PERCENT = bytes32('POOL_MINT_BORROW_PERCENT');
bytes32 public constant POOL_MINT_POWER = bytes32('POOL_MINT_POWER');
//NOT GOVERNANCE
bytes32 public constant AAAA_USER_MINT = bytes32('AAAA_USER_MINT');
bytes32 public constant AAAA_TEAM_MINT = bytes32('AAAA_TEAM_MINT');
bytes32 public constant AAAA_REWAED_MINT = bytes32('AAAA_REWAED_MINT');
bytes32 public constant DEPOSIT_ENABLE = bytes32('DEPOSIT_ENABLE');
bytes32 public constant WITHDRAW_ENABLE = bytes32('WITHDRAW_ENABLE');
bytes32 public constant BORROW_ENABLE = bytes32('BORROW_ENABLE');
bytes32 public constant REPAY_ENABLE = bytes32('REPAY_ENABLE');
bytes32 public constant LIQUIDATION_ENABLE = bytes32('LIQUIDATION_ENABLE');
bytes32 public constant REINVEST_ENABLE = bytes32('REINVEST_ENABLE');
bytes32 public constant INTEREST_BUYBACK_SHARE = bytes32('INTEREST_BUYBACK_SHARE');
//POOL
bytes32 public constant POOL_PRICE = bytes32('POOL_PRICE');
//wallet
bytes32 public constant TEAM = bytes32('team');
bytes32 public constant SPARE = bytes32('spare');
bytes32 public constant REWARD = bytes32('reward');
}
// Root file: contracts/AAAAGovernance.sol
pragma solidity >=0.5.16;
// import 'contracts/libraries/SafeMath.sol';
// import 'contracts/libraries/TransferHelper.sol';
// import 'contracts/modules/Configable.sol';
// import 'contracts/modules/ConfigNames.sol';
interface IAAAAFactory {
function createBallot(address _creator, address _pool,
bytes32 _name, uint _value, uint _reward, string calldata _subject, string calldata _content, bytes calldata _bytecode) external returns (address ballot);
}
interface IAAAABallot {
function vote(address _user, uint _index) external;
function execute(address _user) external;
function executed() external returns (bool);
function end() external returns (bool);
function pass() external returns (bool);
function expire() external returns (bool);
function value() external returns (uint);
function name() external returns (bytes32);
function pool() external returns (address);
}
interface IAAAAMint {
function changeInterestRatePerBlock(uint value) external returns (bool);
function sync() external;
}
interface IAAAAShare {
function lockStake(address _user) external;
}
contract AAAAGovernance is Configable {
function createProposal(address _pool, bytes32 _key, uint _value, string calldata _subject, string calldata _content, bytes calldata _bytecode) external {
}
function voteProposal(address _ballot, uint _index) external {
}
function executeProposal(address _ballot) external {
require(IAAAABallot(_ballot).end(), "Vote not end");
require(!IAAAABallot(_ballot).expire(), "Vote expire");
require(<FILL_ME>)
require(!IAAAABallot(_ballot).executed(), "Vote executed");
bytes32 key = IAAAABallot(_ballot).name();
uint value = IAAAABallot(_ballot).value();
address pool = IAAAABallot(_ballot).pool();
_checkValid(pool, key, value);
if(key == ConfigNames.MINT_AMOUNT_PER_BLOCK) {
IConfig(config).setValue(key, value);
IAAAAMint(IConfig(config).mint()).sync();
} else if(pool == address(0)) {
IConfig(config).setValue(key, value);
} else {
IConfig(config).setPoolValue(pool, key, value);
}
IAAAABallot(_ballot).execute(msg.sender);
}
function _checkValid(address _pool, bytes32 _key, uint _value) view internal {
}
}
| IAAAABallot(_ballot).pass(),"Vote not pass" | 59,766 | IAAAABallot(_ballot).pass() |
"Vote executed" | // Dependency file: contracts/libraries/SafeMath.sol
// SPDX-License-Identifier: MIT
// pragma solidity >=0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
// Dependency file: contracts/libraries/TransferHelper.sol
// pragma solidity >=0.6.0;
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 {
}
}
// Dependency file: contracts/modules/Configable.sol
// pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
interface IConfig {
function developer() external view returns (address);
function platform() external view returns (address);
function factory() external view returns (address);
function mint() external view returns (address);
function token() external view returns (address);
function developPercent() external view returns (uint);
function share() external view returns (address);
function base() external view returns (address);
function governor() external view returns (address);
function getPoolValue(address pool, bytes32 key) external view returns (uint);
function getValue(bytes32 key) external view returns(uint);
function getParams(bytes32 key) external view returns(uint, uint, uint, uint);
function getPoolParams(address pool, bytes32 key) external view returns(uint, uint, uint, uint);
function wallets(bytes32 key) external view returns(address);
function setValue(bytes32 key, uint value) external;
function setPoolValue(address pool, bytes32 key, uint value) external;
function setParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function setPoolParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function initPoolParams(address _pool) external;
function isMintToken(address _token) external returns (bool);
function prices(address _token) external returns (uint);
function convertTokenAmount(address _fromToken, address _toToken, uint _fromAmount) external view returns (uint);
function DAY() external view returns (uint);
function WETH() external view returns (address);
}
contract Configable {
address public config;
address public owner;
event OwnerChanged(address indexed _oldOwner, address indexed _newOwner);
constructor() public {
}
function setupConfig(address _config) external onlyOwner {
}
modifier onlyOwner() {
}
modifier onlyDeveloper() {
}
modifier onlyPlatform() {
}
modifier onlyFactory() {
}
modifier onlyGovernor() {
}
}
// Dependency file: contracts/modules/ConfigNames.sol
// pragma solidity >=0.5.16;
library ConfigNames {
//GOVERNANCE
bytes32 public constant PROPOSAL_VOTE_DURATION = bytes32('PROPOSAL_VOTE_DURATION');
bytes32 public constant PROPOSAL_EXECUTE_DURATION = bytes32('PROPOSAL_EXECUTE_DURATION');
bytes32 public constant PROPOSAL_CREATE_COST = bytes32('PROPOSAL_CREATE_COST');
bytes32 public constant STAKE_LOCK_TIME = bytes32('STAKE_LOCK_TIME');
bytes32 public constant MINT_AMOUNT_PER_BLOCK = bytes32('MINT_AMOUNT_PER_BLOCK');
bytes32 public constant INTEREST_PLATFORM_SHARE = bytes32('INTEREST_PLATFORM_SHARE');
bytes32 public constant CHANGE_PRICE_DURATION = bytes32('CHANGE_PRICE_DURATION');
bytes32 public constant CHANGE_PRICE_PERCENT = bytes32('CHANGE_PRICE_PERCENT');
// POOL
bytes32 public constant POOL_BASE_INTERESTS = bytes32('POOL_BASE_INTERESTS');
bytes32 public constant POOL_MARKET_FRENZY = bytes32('POOL_MARKET_FRENZY');
bytes32 public constant POOL_PLEDGE_RATE = bytes32('POOL_PLEDGE_RATE');
bytes32 public constant POOL_LIQUIDATION_RATE = bytes32('POOL_LIQUIDATION_RATE');
bytes32 public constant POOL_MINT_BORROW_PERCENT = bytes32('POOL_MINT_BORROW_PERCENT');
bytes32 public constant POOL_MINT_POWER = bytes32('POOL_MINT_POWER');
//NOT GOVERNANCE
bytes32 public constant AAAA_USER_MINT = bytes32('AAAA_USER_MINT');
bytes32 public constant AAAA_TEAM_MINT = bytes32('AAAA_TEAM_MINT');
bytes32 public constant AAAA_REWAED_MINT = bytes32('AAAA_REWAED_MINT');
bytes32 public constant DEPOSIT_ENABLE = bytes32('DEPOSIT_ENABLE');
bytes32 public constant WITHDRAW_ENABLE = bytes32('WITHDRAW_ENABLE');
bytes32 public constant BORROW_ENABLE = bytes32('BORROW_ENABLE');
bytes32 public constant REPAY_ENABLE = bytes32('REPAY_ENABLE');
bytes32 public constant LIQUIDATION_ENABLE = bytes32('LIQUIDATION_ENABLE');
bytes32 public constant REINVEST_ENABLE = bytes32('REINVEST_ENABLE');
bytes32 public constant INTEREST_BUYBACK_SHARE = bytes32('INTEREST_BUYBACK_SHARE');
//POOL
bytes32 public constant POOL_PRICE = bytes32('POOL_PRICE');
//wallet
bytes32 public constant TEAM = bytes32('team');
bytes32 public constant SPARE = bytes32('spare');
bytes32 public constant REWARD = bytes32('reward');
}
// Root file: contracts/AAAAGovernance.sol
pragma solidity >=0.5.16;
// import 'contracts/libraries/SafeMath.sol';
// import 'contracts/libraries/TransferHelper.sol';
// import 'contracts/modules/Configable.sol';
// import 'contracts/modules/ConfigNames.sol';
interface IAAAAFactory {
function createBallot(address _creator, address _pool,
bytes32 _name, uint _value, uint _reward, string calldata _subject, string calldata _content, bytes calldata _bytecode) external returns (address ballot);
}
interface IAAAABallot {
function vote(address _user, uint _index) external;
function execute(address _user) external;
function executed() external returns (bool);
function end() external returns (bool);
function pass() external returns (bool);
function expire() external returns (bool);
function value() external returns (uint);
function name() external returns (bytes32);
function pool() external returns (address);
}
interface IAAAAMint {
function changeInterestRatePerBlock(uint value) external returns (bool);
function sync() external;
}
interface IAAAAShare {
function lockStake(address _user) external;
}
contract AAAAGovernance is Configable {
function createProposal(address _pool, bytes32 _key, uint _value, string calldata _subject, string calldata _content, bytes calldata _bytecode) external {
}
function voteProposal(address _ballot, uint _index) external {
}
function executeProposal(address _ballot) external {
require(IAAAABallot(_ballot).end(), "Vote not end");
require(!IAAAABallot(_ballot).expire(), "Vote expire");
require(IAAAABallot(_ballot).pass(), "Vote not pass");
require(<FILL_ME>)
bytes32 key = IAAAABallot(_ballot).name();
uint value = IAAAABallot(_ballot).value();
address pool = IAAAABallot(_ballot).pool();
_checkValid(pool, key, value);
if(key == ConfigNames.MINT_AMOUNT_PER_BLOCK) {
IConfig(config).setValue(key, value);
IAAAAMint(IConfig(config).mint()).sync();
} else if(pool == address(0)) {
IConfig(config).setValue(key, value);
} else {
IConfig(config).setPoolValue(pool, key, value);
}
IAAAABallot(_ballot).execute(msg.sender);
}
function _checkValid(address _pool, bytes32 _key, uint _value) view internal {
}
}
| !IAAAABallot(_ballot).executed(),"Vote executed" | 59,766 | !IAAAABallot(_ballot).executed() |
"INVALID SPAN" | // Dependency file: contracts/libraries/SafeMath.sol
// SPDX-License-Identifier: MIT
// pragma solidity >=0.6.0;
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
// Dependency file: contracts/libraries/TransferHelper.sol
// pragma solidity >=0.6.0;
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 {
}
}
// Dependency file: contracts/modules/Configable.sol
// pragma solidity >=0.5.16;
pragma experimental ABIEncoderV2;
interface IConfig {
function developer() external view returns (address);
function platform() external view returns (address);
function factory() external view returns (address);
function mint() external view returns (address);
function token() external view returns (address);
function developPercent() external view returns (uint);
function share() external view returns (address);
function base() external view returns (address);
function governor() external view returns (address);
function getPoolValue(address pool, bytes32 key) external view returns (uint);
function getValue(bytes32 key) external view returns(uint);
function getParams(bytes32 key) external view returns(uint, uint, uint, uint);
function getPoolParams(address pool, bytes32 key) external view returns(uint, uint, uint, uint);
function wallets(bytes32 key) external view returns(address);
function setValue(bytes32 key, uint value) external;
function setPoolValue(address pool, bytes32 key, uint value) external;
function setParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function setPoolParams(bytes32 _key, uint _min, uint _max, uint _span, uint _value) external;
function initPoolParams(address _pool) external;
function isMintToken(address _token) external returns (bool);
function prices(address _token) external returns (uint);
function convertTokenAmount(address _fromToken, address _toToken, uint _fromAmount) external view returns (uint);
function DAY() external view returns (uint);
function WETH() external view returns (address);
}
contract Configable {
address public config;
address public owner;
event OwnerChanged(address indexed _oldOwner, address indexed _newOwner);
constructor() public {
}
function setupConfig(address _config) external onlyOwner {
}
modifier onlyOwner() {
}
modifier onlyDeveloper() {
}
modifier onlyPlatform() {
}
modifier onlyFactory() {
}
modifier onlyGovernor() {
}
}
// Dependency file: contracts/modules/ConfigNames.sol
// pragma solidity >=0.5.16;
library ConfigNames {
//GOVERNANCE
bytes32 public constant PROPOSAL_VOTE_DURATION = bytes32('PROPOSAL_VOTE_DURATION');
bytes32 public constant PROPOSAL_EXECUTE_DURATION = bytes32('PROPOSAL_EXECUTE_DURATION');
bytes32 public constant PROPOSAL_CREATE_COST = bytes32('PROPOSAL_CREATE_COST');
bytes32 public constant STAKE_LOCK_TIME = bytes32('STAKE_LOCK_TIME');
bytes32 public constant MINT_AMOUNT_PER_BLOCK = bytes32('MINT_AMOUNT_PER_BLOCK');
bytes32 public constant INTEREST_PLATFORM_SHARE = bytes32('INTEREST_PLATFORM_SHARE');
bytes32 public constant CHANGE_PRICE_DURATION = bytes32('CHANGE_PRICE_DURATION');
bytes32 public constant CHANGE_PRICE_PERCENT = bytes32('CHANGE_PRICE_PERCENT');
// POOL
bytes32 public constant POOL_BASE_INTERESTS = bytes32('POOL_BASE_INTERESTS');
bytes32 public constant POOL_MARKET_FRENZY = bytes32('POOL_MARKET_FRENZY');
bytes32 public constant POOL_PLEDGE_RATE = bytes32('POOL_PLEDGE_RATE');
bytes32 public constant POOL_LIQUIDATION_RATE = bytes32('POOL_LIQUIDATION_RATE');
bytes32 public constant POOL_MINT_BORROW_PERCENT = bytes32('POOL_MINT_BORROW_PERCENT');
bytes32 public constant POOL_MINT_POWER = bytes32('POOL_MINT_POWER');
//NOT GOVERNANCE
bytes32 public constant AAAA_USER_MINT = bytes32('AAAA_USER_MINT');
bytes32 public constant AAAA_TEAM_MINT = bytes32('AAAA_TEAM_MINT');
bytes32 public constant AAAA_REWAED_MINT = bytes32('AAAA_REWAED_MINT');
bytes32 public constant DEPOSIT_ENABLE = bytes32('DEPOSIT_ENABLE');
bytes32 public constant WITHDRAW_ENABLE = bytes32('WITHDRAW_ENABLE');
bytes32 public constant BORROW_ENABLE = bytes32('BORROW_ENABLE');
bytes32 public constant REPAY_ENABLE = bytes32('REPAY_ENABLE');
bytes32 public constant LIQUIDATION_ENABLE = bytes32('LIQUIDATION_ENABLE');
bytes32 public constant REINVEST_ENABLE = bytes32('REINVEST_ENABLE');
bytes32 public constant INTEREST_BUYBACK_SHARE = bytes32('INTEREST_BUYBACK_SHARE');
//POOL
bytes32 public constant POOL_PRICE = bytes32('POOL_PRICE');
//wallet
bytes32 public constant TEAM = bytes32('team');
bytes32 public constant SPARE = bytes32('spare');
bytes32 public constant REWARD = bytes32('reward');
}
// Root file: contracts/AAAAGovernance.sol
pragma solidity >=0.5.16;
// import 'contracts/libraries/SafeMath.sol';
// import 'contracts/libraries/TransferHelper.sol';
// import 'contracts/modules/Configable.sol';
// import 'contracts/modules/ConfigNames.sol';
interface IAAAAFactory {
function createBallot(address _creator, address _pool,
bytes32 _name, uint _value, uint _reward, string calldata _subject, string calldata _content, bytes calldata _bytecode) external returns (address ballot);
}
interface IAAAABallot {
function vote(address _user, uint _index) external;
function execute(address _user) external;
function executed() external returns (bool);
function end() external returns (bool);
function pass() external returns (bool);
function expire() external returns (bool);
function value() external returns (uint);
function name() external returns (bytes32);
function pool() external returns (address);
}
interface IAAAAMint {
function changeInterestRatePerBlock(uint value) external returns (bool);
function sync() external;
}
interface IAAAAShare {
function lockStake(address _user) external;
}
contract AAAAGovernance is Configable {
function createProposal(address _pool, bytes32 _key, uint _value, string calldata _subject, string calldata _content, bytes calldata _bytecode) external {
}
function voteProposal(address _ballot, uint _index) external {
}
function executeProposal(address _ballot) external {
}
function _checkValid(address _pool, bytes32 _key, uint _value) view internal {
(uint min, uint max, uint span, uint value) = _pool == address(0) ? IConfig(config).getParams(_key): IConfig(config).getPoolParams(_pool, _key);
require(_value <= max && _value >= min, "INVALID VALUE");
require(_value != value, "Same VALUE");
require(<FILL_ME>)
}
}
| value+span>=_value&&_value+span>=value,"INVALID SPAN" | 59,766 | value+span>=_value&&_value+span>=value |
"controller frontend does not point back" | /**
* Copyright 2019 Monerium ehf.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity 0.4.24;
/**
* @title TokenFrontend
* @dev This contract implements a token forwarder.
* The token frontend is [ERC20 and ERC677] compliant and forwards
* standard methods to a controller. The primary function is to allow
* for a statically deployed contract for users to interact with while
* simultaneously allow the controllers to be upgraded when bugs are
* discovered or new functionality needs to be added.
*/
contract TokenFrontend is Destructible, Claimable, CanReclaimToken, NoOwner, IERC20 {
SmartController internal controller;
string public name;
string public symbol;
bytes3 public ticker;
/**
* @dev Emitted when tokens are transferred.
* @param from Sender address.
* @param to Recipient address.
* @param amount Number of tokens transferred.
*/
event Transfer(address indexed from, address indexed to, uint amount);
/**
* @dev Emitted when tokens are transferred.
* @param from Sender address.
* @param to Recipient address.
* @param amount Number of tokens transferred.
* @param data Additional data passed to the recipient's tokenFallback method.
*/
event Transfer(address indexed from, address indexed to, uint amount, bytes data);
/**
* @dev Emitted when spender is granted an allowance.
* @param owner Address of the owner of the tokens to spend.
* @param spender The address of the future spender.
* @param amount The allowance of the spender.
*/
event Approval(address indexed owner, address indexed spender, uint amount);
/**
* @dev Emitted when updating the controller.
* @param ticker Three letter ticker representing the currency.
* @param old Address of the old controller.
* @param current Address of the new controller.
*/
event Controller(bytes3 indexed ticker, address indexed old, address indexed current);
/**
* @dev Contract constructor.
* @notice The contract is an abstract contract as a result of the internal modifier.
* @param name_ Token name.
* @param symbol_ Token symbol.
* @param ticker_ 3 letter currency ticker.
*/
constructor(string name_, string symbol_, bytes3 ticker_) internal {
}
/**
* @dev Sets a new controller.
* @param address_ Address of the controller.
*/
function setController(address address_) external onlyOwner {
require(address_ != 0x0, "controller address cannot be the null address");
emit Controller(ticker, controller, address_);
controller = SmartController(address_);
require(<FILL_ME>)
require(controller.ticker() == ticker, "ticker does not match controller ticket");
}
/**
* @dev Transfers tokens [ERC20].
* @param to Recipient address.
* @param amount Number of tokens to transfer.
*/
function transfer(address to, uint amount) external returns (bool ok) {
}
/**
* @dev Transfers tokens from a specific address [ERC20].
* The address owner has to approve the spender beforehand.
* @param from Address to debet the tokens from.
* @param to Recipient address.
* @param amount Number of tokens to transfer.
*/
function transferFrom(address from, address to, uint amount) external returns (bool ok) {
}
/**
* @dev Approves a spender [ERC20].
* Note that using the approve/transferFrom presents a possible
* security vulnerability described in:
* https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/edit#heading=h.quou09mcbpzw
* Use transferAndCall to mitigate.
* @param spender The address of the future spender.
* @param amount The allowance of the spender.
*/
function approve(address spender, uint amount) external returns (bool ok) {
}
/**
* @dev Transfers tokens and subsequently calls a method on the recipient [ERC677].
* If the recipient is a non-contract address this method behaves just like transfer.
* @param to Recipient address.
* @param amount Number of tokens to transfer.
* @param data Additional data passed to the recipient's tokenFallback method.
*/
function transferAndCall(address to, uint256 amount, bytes data)
external
returns (bool ok)
{
}
/**
* @dev Mints new tokens.
* @param to Address to credit the tokens.
* @param amount Number of tokens to mint.
*/
function mintTo(address to, uint amount)
external
returns (bool ok)
{
}
/**
* @dev Burns tokens from token owner.
* This removfes the burned tokens from circulation.
* @param from Address of the token owner.
* @param amount Number of tokens to burn.
* @param h Hash which the token owner signed.
* @param v Signature component.
* @param r Signature component.
* @param s Sigature component.
*/
function burnFrom(address from, uint amount, bytes32 h, uint8 v, bytes32 r, bytes32 s)
external
returns (bool ok)
{
}
/**
* @dev Recovers tokens from an address and reissues them to another address.
* In case a user loses its private key the tokens can be recovered by burning
* the tokens from that address and reissuing to a new address.
* To recover tokens the contract owner needs to provide a signature
* proving that the token owner has authorized the owner to do so.
* @param from Address to burn tokens from.
* @param to Address to mint tokens to.
* @param h Hash which the token owner signed.
* @param v Signature component.
* @param r Signature component.
* @param s Sigature component.
* @return Amount recovered.
*/
function recover(address from, address to, bytes32 h, uint8 v, bytes32 r, bytes32 s)
external
returns (uint amount)
{
}
/**
* @dev Gets the current controller.
* @return Address of the controller.
*/
function getController() external view returns (address) {
}
/**
* @dev Returns the total supply.
* @return Number of tokens.
*/
function totalSupply() external view returns (uint) {
}
/**
* @dev Returns the number tokens associated with an address.
* @param who Address to lookup.
* @return Balance of address.
*/
function balanceOf(address who) external view returns (uint) {
}
/**
* @dev Returns the allowance for a spender
* @param owner The address of the owner of the tokens.
* @param spender The address of the spender.
* @return Number of tokens the spender is allowed to spend.
*/
function allowance(address owner, address spender) external view returns (uint) {
}
/**
* @dev Returns the number of decimals in one token.
* @return Number of decimals.
*/
function decimals() external view returns (uint) {
}
}
| controller.getFrontend()==address(this),"controller frontend does not point back" | 59,847 | controller.getFrontend()==address(this) |
"ticker does not match controller ticket" | /**
* Copyright 2019 Monerium ehf.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity 0.4.24;
/**
* @title TokenFrontend
* @dev This contract implements a token forwarder.
* The token frontend is [ERC20 and ERC677] compliant and forwards
* standard methods to a controller. The primary function is to allow
* for a statically deployed contract for users to interact with while
* simultaneously allow the controllers to be upgraded when bugs are
* discovered or new functionality needs to be added.
*/
contract TokenFrontend is Destructible, Claimable, CanReclaimToken, NoOwner, IERC20 {
SmartController internal controller;
string public name;
string public symbol;
bytes3 public ticker;
/**
* @dev Emitted when tokens are transferred.
* @param from Sender address.
* @param to Recipient address.
* @param amount Number of tokens transferred.
*/
event Transfer(address indexed from, address indexed to, uint amount);
/**
* @dev Emitted when tokens are transferred.
* @param from Sender address.
* @param to Recipient address.
* @param amount Number of tokens transferred.
* @param data Additional data passed to the recipient's tokenFallback method.
*/
event Transfer(address indexed from, address indexed to, uint amount, bytes data);
/**
* @dev Emitted when spender is granted an allowance.
* @param owner Address of the owner of the tokens to spend.
* @param spender The address of the future spender.
* @param amount The allowance of the spender.
*/
event Approval(address indexed owner, address indexed spender, uint amount);
/**
* @dev Emitted when updating the controller.
* @param ticker Three letter ticker representing the currency.
* @param old Address of the old controller.
* @param current Address of the new controller.
*/
event Controller(bytes3 indexed ticker, address indexed old, address indexed current);
/**
* @dev Contract constructor.
* @notice The contract is an abstract contract as a result of the internal modifier.
* @param name_ Token name.
* @param symbol_ Token symbol.
* @param ticker_ 3 letter currency ticker.
*/
constructor(string name_, string symbol_, bytes3 ticker_) internal {
}
/**
* @dev Sets a new controller.
* @param address_ Address of the controller.
*/
function setController(address address_) external onlyOwner {
require(address_ != 0x0, "controller address cannot be the null address");
emit Controller(ticker, controller, address_);
controller = SmartController(address_);
require(controller.getFrontend() == address(this), "controller frontend does not point back");
require(<FILL_ME>)
}
/**
* @dev Transfers tokens [ERC20].
* @param to Recipient address.
* @param amount Number of tokens to transfer.
*/
function transfer(address to, uint amount) external returns (bool ok) {
}
/**
* @dev Transfers tokens from a specific address [ERC20].
* The address owner has to approve the spender beforehand.
* @param from Address to debet the tokens from.
* @param to Recipient address.
* @param amount Number of tokens to transfer.
*/
function transferFrom(address from, address to, uint amount) external returns (bool ok) {
}
/**
* @dev Approves a spender [ERC20].
* Note that using the approve/transferFrom presents a possible
* security vulnerability described in:
* https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/edit#heading=h.quou09mcbpzw
* Use transferAndCall to mitigate.
* @param spender The address of the future spender.
* @param amount The allowance of the spender.
*/
function approve(address spender, uint amount) external returns (bool ok) {
}
/**
* @dev Transfers tokens and subsequently calls a method on the recipient [ERC677].
* If the recipient is a non-contract address this method behaves just like transfer.
* @param to Recipient address.
* @param amount Number of tokens to transfer.
* @param data Additional data passed to the recipient's tokenFallback method.
*/
function transferAndCall(address to, uint256 amount, bytes data)
external
returns (bool ok)
{
}
/**
* @dev Mints new tokens.
* @param to Address to credit the tokens.
* @param amount Number of tokens to mint.
*/
function mintTo(address to, uint amount)
external
returns (bool ok)
{
}
/**
* @dev Burns tokens from token owner.
* This removfes the burned tokens from circulation.
* @param from Address of the token owner.
* @param amount Number of tokens to burn.
* @param h Hash which the token owner signed.
* @param v Signature component.
* @param r Signature component.
* @param s Sigature component.
*/
function burnFrom(address from, uint amount, bytes32 h, uint8 v, bytes32 r, bytes32 s)
external
returns (bool ok)
{
}
/**
* @dev Recovers tokens from an address and reissues them to another address.
* In case a user loses its private key the tokens can be recovered by burning
* the tokens from that address and reissuing to a new address.
* To recover tokens the contract owner needs to provide a signature
* proving that the token owner has authorized the owner to do so.
* @param from Address to burn tokens from.
* @param to Address to mint tokens to.
* @param h Hash which the token owner signed.
* @param v Signature component.
* @param r Signature component.
* @param s Sigature component.
* @return Amount recovered.
*/
function recover(address from, address to, bytes32 h, uint8 v, bytes32 r, bytes32 s)
external
returns (uint amount)
{
}
/**
* @dev Gets the current controller.
* @return Address of the controller.
*/
function getController() external view returns (address) {
}
/**
* @dev Returns the total supply.
* @return Number of tokens.
*/
function totalSupply() external view returns (uint) {
}
/**
* @dev Returns the number tokens associated with an address.
* @param who Address to lookup.
* @return Balance of address.
*/
function balanceOf(address who) external view returns (uint) {
}
/**
* @dev Returns the allowance for a spender
* @param owner The address of the owner of the tokens.
* @param spender The address of the spender.
* @return Number of tokens the spender is allowed to spend.
*/
function allowance(address owner, address spender) external view returns (uint) {
}
/**
* @dev Returns the number of decimals in one token.
* @return Number of decimals.
*/
function decimals() external view returns (uint) {
}
}
| controller.ticker()==ticker,"ticker does not match controller ticket" | 59,847 | controller.ticker()==ticker |
"Token at supplied address is NOT supported!" | pragma solidity ^0.6.0;
contract PERC20Vault is Withdrawable, IERC777Recipient {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC1820Registry constant private _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
EnumerableSet.AddressSet private supportedTokens;
address public PNETWORK;
IWETH public weth;
event PegIn(
address _tokenAddress,
address _tokenSender,
uint256 _tokenAmount,
string _destinationAddress,
bytes _userData
);
constructor(
address _weth,
address [] memory _tokensToSupport
) public {
}
modifier onlyPNetwork() {
}
receive() external payable {
}
function setWeth(address _weth) external onlyPNetwork {
}
function setPNetwork(address _pnetwork) external onlyPNetwork {
}
function IS_TOKEN_SUPPORTED(address _token) external view returns(bool) {
}
function _owner() internal override returns(address) {
}
function adminWithdrawAllowed(address asset) internal override view returns(uint) {
}
function addSupportedToken(
address _tokenAddress
)
external
onlyPNetwork
returns (bool SUCCESS)
{
}
function removeSupportedToken(
address _tokenAddress
)
external
onlyPNetwork
returns (bool SUCCESS)
{
}
function getSupportedTokens() external view returns(address[] memory res) {
}
function pegIn(
uint256 _tokenAmount,
address _tokenAddress,
string calldata _destinationAddress
)
external
returns (bool)
{
}
function pegIn(
uint256 _tokenAmount,
address _tokenAddress,
string memory _destinationAddress,
bytes memory _userData
)
public
returns (bool)
{
require(<FILL_ME>)
require(_tokenAmount > 0, "Token amount must be greater than zero!");
IERC20(_tokenAddress).safeTransferFrom(msg.sender, address(this), _tokenAmount);
emit PegIn(_tokenAddress, msg.sender, _tokenAmount, _destinationAddress, _userData);
return true;
}
/**
* @dev Implementation of IERC777Recipient.
*/
function tokensReceived(
address /*operator*/,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata /*operatorData*/
) external override {
}
function pegInEth(string calldata _destinationAddress)
external
payable
returns (bool)
{
}
function pegInEth(
string memory _destinationAddress,
bytes memory _userData
)
public
payable
returns (bool)
{
}
function pegOut(
address payable _tokenRecipient,
address _tokenAddress,
uint256 _tokenAmount
)
external
onlyPNetwork
returns (bool)
{
}
function migrate(
address payable _to
)
external
onlyPNetwork
{
}
function destroy()
external
onlyPNetwork
{
}
function migrateSingle(
address payable _to,
address _tokenAddress
)
external
onlyPNetwork
{
}
function _migrateSingle(
address payable _to,
address _tokenAddress
)
private
{
}
}
| supportedTokens.contains(_tokenAddress),"Token at supplied address is NOT supported!" | 59,867 | supportedTokens.contains(_tokenAddress) |
"WETH is NOT supported!" | pragma solidity ^0.6.0;
contract PERC20Vault is Withdrawable, IERC777Recipient {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC1820Registry constant private _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
EnumerableSet.AddressSet private supportedTokens;
address public PNETWORK;
IWETH public weth;
event PegIn(
address _tokenAddress,
address _tokenSender,
uint256 _tokenAmount,
string _destinationAddress,
bytes _userData
);
constructor(
address _weth,
address [] memory _tokensToSupport
) public {
}
modifier onlyPNetwork() {
}
receive() external payable {
}
function setWeth(address _weth) external onlyPNetwork {
}
function setPNetwork(address _pnetwork) external onlyPNetwork {
}
function IS_TOKEN_SUPPORTED(address _token) external view returns(bool) {
}
function _owner() internal override returns(address) {
}
function adminWithdrawAllowed(address asset) internal override view returns(uint) {
}
function addSupportedToken(
address _tokenAddress
)
external
onlyPNetwork
returns (bool SUCCESS)
{
}
function removeSupportedToken(
address _tokenAddress
)
external
onlyPNetwork
returns (bool SUCCESS)
{
}
function getSupportedTokens() external view returns(address[] memory res) {
}
function pegIn(
uint256 _tokenAmount,
address _tokenAddress,
string calldata _destinationAddress
)
external
returns (bool)
{
}
function pegIn(
uint256 _tokenAmount,
address _tokenAddress,
string memory _destinationAddress,
bytes memory _userData
)
public
returns (bool)
{
}
/**
* @dev Implementation of IERC777Recipient.
*/
function tokensReceived(
address /*operator*/,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata /*operatorData*/
) external override {
}
function pegInEth(string calldata _destinationAddress)
external
payable
returns (bool)
{
}
function pegInEth(
string memory _destinationAddress,
bytes memory _userData
)
public
payable
returns (bool)
{
require(<FILL_ME>)
require(msg.value > 0, "Ethers amount must be greater than zero!");
weth.deposit.value(msg.value)();
emit PegIn(address(weth), msg.sender, msg.value, _destinationAddress, _userData);
return true;
}
function pegOut(
address payable _tokenRecipient,
address _tokenAddress,
uint256 _tokenAmount
)
external
onlyPNetwork
returns (bool)
{
}
function migrate(
address payable _to
)
external
onlyPNetwork
{
}
function destroy()
external
onlyPNetwork
{
}
function migrateSingle(
address payable _to,
address _tokenAddress
)
external
onlyPNetwork
{
}
function _migrateSingle(
address payable _to,
address _tokenAddress
)
private
{
}
}
| supportedTokens.contains(address(weth)),"WETH is NOT supported!" | 59,867 | supportedTokens.contains(address(weth)) |
"Balance of supported tokens must be 0" | pragma solidity ^0.6.0;
contract PERC20Vault is Withdrawable, IERC777Recipient {
using SafeERC20 for IERC20;
using EnumerableSet for EnumerableSet.AddressSet;
IERC1820Registry constant private _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
EnumerableSet.AddressSet private supportedTokens;
address public PNETWORK;
IWETH public weth;
event PegIn(
address _tokenAddress,
address _tokenSender,
uint256 _tokenAmount,
string _destinationAddress,
bytes _userData
);
constructor(
address _weth,
address [] memory _tokensToSupport
) public {
}
modifier onlyPNetwork() {
}
receive() external payable {
}
function setWeth(address _weth) external onlyPNetwork {
}
function setPNetwork(address _pnetwork) external onlyPNetwork {
}
function IS_TOKEN_SUPPORTED(address _token) external view returns(bool) {
}
function _owner() internal override returns(address) {
}
function adminWithdrawAllowed(address asset) internal override view returns(uint) {
}
function addSupportedToken(
address _tokenAddress
)
external
onlyPNetwork
returns (bool SUCCESS)
{
}
function removeSupportedToken(
address _tokenAddress
)
external
onlyPNetwork
returns (bool SUCCESS)
{
}
function getSupportedTokens() external view returns(address[] memory res) {
}
function pegIn(
uint256 _tokenAmount,
address _tokenAddress,
string calldata _destinationAddress
)
external
returns (bool)
{
}
function pegIn(
uint256 _tokenAmount,
address _tokenAddress,
string memory _destinationAddress,
bytes memory _userData
)
public
returns (bool)
{
}
/**
* @dev Implementation of IERC777Recipient.
*/
function tokensReceived(
address /*operator*/,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata /*operatorData*/
) external override {
}
function pegInEth(string calldata _destinationAddress)
external
payable
returns (bool)
{
}
function pegInEth(
string memory _destinationAddress,
bytes memory _userData
)
public
payable
returns (bool)
{
}
function pegOut(
address payable _tokenRecipient,
address _tokenAddress,
uint256 _tokenAmount
)
external
onlyPNetwork
returns (bool)
{
}
function migrate(
address payable _to
)
external
onlyPNetwork
{
}
function destroy()
external
onlyPNetwork
{
for (uint256 i = 0; i < supportedTokens.length(); i++) {
address tokenAddress = supportedTokens.at(i);
require(<FILL_ME>)
}
selfdestruct(msg.sender);
}
function migrateSingle(
address payable _to,
address _tokenAddress
)
external
onlyPNetwork
{
}
function _migrateSingle(
address payable _to,
address _tokenAddress
)
private
{
}
}
| IERC20(tokenAddress).balanceOf(address(this))==0,"Balance of supported tokens must be 0" | 59,867 | IERC20(tokenAddress).balanceOf(address(this))==0 |
null | pragma solidity ^0.4.19;
contract BdpBaseData {
address public ownerAddress;
address public managerAddress;
address[16] public contracts;
bool public paused = false;
bool public setupComplete = false;
bytes8 public version;
}
library BdpContracts {
function getBdpEntryPoint(address[16] _contracts) pure internal returns (address) {
}
function getBdpController(address[16] _contracts) pure internal returns (address) {
}
function getBdpControllerHelper(address[16] _contracts) pure internal returns (address) {
}
function getBdpDataStorage(address[16] _contracts) pure internal returns (address) {
}
function getBdpImageStorage(address[16] _contracts) pure internal returns (address) {
}
function getBdpOwnershipStorage(address[16] _contracts) pure internal returns (address) {
}
function getBdpPriceStorage(address[16] _contracts) pure internal returns (address) {
}
}
contract BdpBase is BdpBaseData {
modifier onlyOwner() {
}
modifier onlyAuthorized() {
}
modifier whenContractActive() {
require(<FILL_ME>)
_;
}
modifier storageAccessControl() {
}
function setOwner(address _newOwner) external onlyOwner {
}
function setManager(address _newManager) external onlyOwner {
}
function setContracts(address[16] _contracts) external onlyOwner {
}
function pause() external onlyAuthorized {
}
function unpause() external onlyOwner {
}
function setSetupComplete() external onlyOwner {
}
function kill() public onlyOwner {
}
}
contract BdpPriceStorage is BdpBase {
uint64[1001] public pricePoints;
uint256 public pricePointsLength = 0;
address public forwardPurchaseFeesTo = address(0);
address public forwardUpdateFeesTo = address(0);
function getPricePointsLength() view public returns (uint256) {
}
function getPricePoint(uint256 _i) view public returns (uint256) {
}
function setPricePoints(uint64[] _pricePoints) public storageAccessControl {
}
function appendPricePoints(uint64[] _pricePoints) public storageAccessControl {
}
function getForwardPurchaseFeesTo() view public returns (address) {
}
function setForwardPurchaseFeesTo(address _forwardPurchaseFeesTo) public storageAccessControl {
}
function getForwardUpdateFeesTo() view public returns (address) {
}
function setForwardUpdateFeesTo(address _forwardUpdateFeesTo) public storageAccessControl {
}
function BdpPriceStorage(bytes8 _version) public {
}
}
| !paused&&setupComplete | 59,907 | !paused&&setupComplete |
null | pragma solidity ^0.4.19;
contract BdpBaseData {
address public ownerAddress;
address public managerAddress;
address[16] public contracts;
bool public paused = false;
bool public setupComplete = false;
bytes8 public version;
}
library BdpContracts {
function getBdpEntryPoint(address[16] _contracts) pure internal returns (address) {
}
function getBdpController(address[16] _contracts) pure internal returns (address) {
}
function getBdpControllerHelper(address[16] _contracts) pure internal returns (address) {
}
function getBdpDataStorage(address[16] _contracts) pure internal returns (address) {
}
function getBdpImageStorage(address[16] _contracts) pure internal returns (address) {
}
function getBdpOwnershipStorage(address[16] _contracts) pure internal returns (address) {
}
function getBdpPriceStorage(address[16] _contracts) pure internal returns (address) {
}
}
contract BdpBase is BdpBaseData {
modifier onlyOwner() {
}
modifier onlyAuthorized() {
}
modifier whenContractActive() {
}
modifier storageAccessControl() {
require(<FILL_ME>)
_;
}
function setOwner(address _newOwner) external onlyOwner {
}
function setManager(address _newManager) external onlyOwner {
}
function setContracts(address[16] _contracts) external onlyOwner {
}
function pause() external onlyAuthorized {
}
function unpause() external onlyOwner {
}
function setSetupComplete() external onlyOwner {
}
function kill() public onlyOwner {
}
}
contract BdpPriceStorage is BdpBase {
uint64[1001] public pricePoints;
uint256 public pricePointsLength = 0;
address public forwardPurchaseFeesTo = address(0);
address public forwardUpdateFeesTo = address(0);
function getPricePointsLength() view public returns (uint256) {
}
function getPricePoint(uint256 _i) view public returns (uint256) {
}
function setPricePoints(uint64[] _pricePoints) public storageAccessControl {
}
function appendPricePoints(uint64[] _pricePoints) public storageAccessControl {
}
function getForwardPurchaseFeesTo() view public returns (address) {
}
function setForwardPurchaseFeesTo(address _forwardPurchaseFeesTo) public storageAccessControl {
}
function getForwardUpdateFeesTo() view public returns (address) {
}
function setForwardUpdateFeesTo(address _forwardUpdateFeesTo) public storageAccessControl {
}
function BdpPriceStorage(bytes8 _version) public {
}
}
| (!setupComplete&&(msg.sender==ownerAddress||msg.sender==managerAddress))||(setupComplete&&!paused&&(msg.sender==BdpContracts.getBdpEntryPoint(contracts))) | 59,907 | (!setupComplete&&(msg.sender==ownerAddress||msg.sender==managerAddress))||(setupComplete&&!paused&&(msg.sender==BdpContracts.getBdpEntryPoint(contracts))) |
null | pragma solidity ^0.4.13;
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 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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant 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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @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 constant returns (uint256 balance) {
}
}
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 constant returns (uint256 remaining) {
}
/**
* 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
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
}
}
contract 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 public returns (bool) {
}
}
contract TssToken is MintableToken, BurnableToken {
string public constant name = "TssToken";
string public constant symbol = "TSS";
uint256 public constant decimals = 18;
function TssToken(address initialAccount, uint256 initialBalance) public {
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
/**
* event for token purchase logging
* @param purchaser who paid for the tokens
* @param beneficiary who got the tokens
* @param value weis paid for purchase
* @param amount amount of tokens purchased
*/
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Debug(bytes32 text, uint256);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
}
// fallback function can be used to buy tokens
function () payable {
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract TssCrowdsale is Crowdsale, Pausable {
enum LifecycleStage {
DEPLOYMENT,
MINTING,
PRESALE,
CROWDSALE_PHASE_1,
CROWDSALE_PHASE_2,
CROWDSALE_PHASE_3,
POSTSALE
}
uint256 public CROWDSALE_PHASE_1_START;
uint256 public CROWDSALE_PHASE_2_START;
uint256 public CROWDSALE_PHASE_3_START;
uint256 public POSTSALE_START;
address public FOUNDER_WALLET;
address public BOUNTY_WALLET;
address public FUTURE_WALLET;
address public CROWDSALE_WALLET;
address public PRESALE_WALLET;
address PROCEEDS_WALLET;
LifecycleStage public currentStage;
function assertValidParameters() internal {
require(CROWDSALE_PHASE_1_START > 0);
require(CROWDSALE_PHASE_2_START > 0);
require(CROWDSALE_PHASE_3_START > 0);
require(POSTSALE_START > 0);
require(<FILL_ME>)
require(address(BOUNTY_WALLET) != 0);
require(address(FUTURE_WALLET) != 0);
}
/**
* Used for forcing ensureStage modifier
*/
function setCurrentStage() onlyOwner ensureStage returns (bool) {
}
modifier ensureStage() {
}
function getCurrentRate() constant returns (uint _rate) {
}
function TssCrowdsale(
uint256 _rate,
address _wallet,
uint256 _phase_1_start,
uint256 _phase_2_start,
uint256 _phase_3_start,
uint256 _postsale_start,
address _founder_wallet,
address _bounty_wallet,
address _future_wallet,
address _presale_wallet)
public
Crowdsale(_phase_1_start, _postsale_start, _rate, _wallet)
{
}
function mintTokens() internal {
}
/**
* Overrides Crowdsale.buyTokens()
*/
function buyTokens(address beneficiary) public
payable
whenNotPaused()
ensureStage()
{
}
/**
* Overrides Crowdsale.validPurchase()
*/
function validPurchase() internal constant returns (bool) {
}
/**
* Overrides Crowdsale.createTokenContract()
*/
function createTokenContract() internal returns (MintableToken) {
}
event CoinsRetrieved(address indexed recipient, uint amount);
function retrieveRemainingCoinsPostSale()
public
onlyOwner
ensureStage()
{
}
/**
There shouldn't be any funds trapped in this contract
but as a failsafe if there are any funds whatsoever, this function exists
*/
function retrieveFunds()
public
onlyOwner
{
}
}
| address(FOUNDER_WALLET)!=0 | 59,946 | address(FOUNDER_WALLET)!=0 |
null | pragma solidity ^0.4.13;
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 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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant 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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @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 constant returns (uint256 balance) {
}
}
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 constant returns (uint256 remaining) {
}
/**
* 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
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
}
}
contract 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 public returns (bool) {
}
}
contract TssToken is MintableToken, BurnableToken {
string public constant name = "TssToken";
string public constant symbol = "TSS";
uint256 public constant decimals = 18;
function TssToken(address initialAccount, uint256 initialBalance) public {
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
/**
* event for token purchase logging
* @param purchaser who paid for the tokens
* @param beneficiary who got the tokens
* @param value weis paid for purchase
* @param amount amount of tokens purchased
*/
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Debug(bytes32 text, uint256);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
}
// fallback function can be used to buy tokens
function () payable {
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract TssCrowdsale is Crowdsale, Pausable {
enum LifecycleStage {
DEPLOYMENT,
MINTING,
PRESALE,
CROWDSALE_PHASE_1,
CROWDSALE_PHASE_2,
CROWDSALE_PHASE_3,
POSTSALE
}
uint256 public CROWDSALE_PHASE_1_START;
uint256 public CROWDSALE_PHASE_2_START;
uint256 public CROWDSALE_PHASE_3_START;
uint256 public POSTSALE_START;
address public FOUNDER_WALLET;
address public BOUNTY_WALLET;
address public FUTURE_WALLET;
address public CROWDSALE_WALLET;
address public PRESALE_WALLET;
address PROCEEDS_WALLET;
LifecycleStage public currentStage;
function assertValidParameters() internal {
require(CROWDSALE_PHASE_1_START > 0);
require(CROWDSALE_PHASE_2_START > 0);
require(CROWDSALE_PHASE_3_START > 0);
require(POSTSALE_START > 0);
require(address(FOUNDER_WALLET) != 0);
require(<FILL_ME>)
require(address(FUTURE_WALLET) != 0);
}
/**
* Used for forcing ensureStage modifier
*/
function setCurrentStage() onlyOwner ensureStage returns (bool) {
}
modifier ensureStage() {
}
function getCurrentRate() constant returns (uint _rate) {
}
function TssCrowdsale(
uint256 _rate,
address _wallet,
uint256 _phase_1_start,
uint256 _phase_2_start,
uint256 _phase_3_start,
uint256 _postsale_start,
address _founder_wallet,
address _bounty_wallet,
address _future_wallet,
address _presale_wallet)
public
Crowdsale(_phase_1_start, _postsale_start, _rate, _wallet)
{
}
function mintTokens() internal {
}
/**
* Overrides Crowdsale.buyTokens()
*/
function buyTokens(address beneficiary) public
payable
whenNotPaused()
ensureStage()
{
}
/**
* Overrides Crowdsale.validPurchase()
*/
function validPurchase() internal constant returns (bool) {
}
/**
* Overrides Crowdsale.createTokenContract()
*/
function createTokenContract() internal returns (MintableToken) {
}
event CoinsRetrieved(address indexed recipient, uint amount);
function retrieveRemainingCoinsPostSale()
public
onlyOwner
ensureStage()
{
}
/**
There shouldn't be any funds trapped in this contract
but as a failsafe if there are any funds whatsoever, this function exists
*/
function retrieveFunds()
public
onlyOwner
{
}
}
| address(BOUNTY_WALLET)!=0 | 59,946 | address(BOUNTY_WALLET)!=0 |
null | pragma solidity ^0.4.13;
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 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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant 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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
/**
* @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 constant returns (uint256 balance) {
}
}
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 constant returns (uint256 remaining) {
}
/**
* 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
*/
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {
}
}
contract 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 public returns (bool) {
}
}
contract TssToken is MintableToken, BurnableToken {
string public constant name = "TssToken";
string public constant symbol = "TSS";
uint256 public constant decimals = 18;
function TssToken(address initialAccount, uint256 initialBalance) public {
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
/**
* event for token purchase logging
* @param purchaser who paid for the tokens
* @param beneficiary who got the tokens
* @param value weis paid for purchase
* @param amount amount of tokens purchased
*/
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Debug(bytes32 text, uint256);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
}
// fallback function can be used to buy tokens
function () payable {
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*/
modifier whenNotPaused() {
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*/
modifier whenPaused() {
}
/**
* @dev called by the owner to pause, triggers stopped state
*/
function pause() onlyOwner whenNotPaused public {
}
/**
* @dev called by the owner to unpause, returns to normal state
*/
function unpause() onlyOwner whenPaused public {
}
}
contract TssCrowdsale is Crowdsale, Pausable {
enum LifecycleStage {
DEPLOYMENT,
MINTING,
PRESALE,
CROWDSALE_PHASE_1,
CROWDSALE_PHASE_2,
CROWDSALE_PHASE_3,
POSTSALE
}
uint256 public CROWDSALE_PHASE_1_START;
uint256 public CROWDSALE_PHASE_2_START;
uint256 public CROWDSALE_PHASE_3_START;
uint256 public POSTSALE_START;
address public FOUNDER_WALLET;
address public BOUNTY_WALLET;
address public FUTURE_WALLET;
address public CROWDSALE_WALLET;
address public PRESALE_WALLET;
address PROCEEDS_WALLET;
LifecycleStage public currentStage;
function assertValidParameters() internal {
require(CROWDSALE_PHASE_1_START > 0);
require(CROWDSALE_PHASE_2_START > 0);
require(CROWDSALE_PHASE_3_START > 0);
require(POSTSALE_START > 0);
require(address(FOUNDER_WALLET) != 0);
require(address(BOUNTY_WALLET) != 0);
require(<FILL_ME>)
}
/**
* Used for forcing ensureStage modifier
*/
function setCurrentStage() onlyOwner ensureStage returns (bool) {
}
modifier ensureStage() {
}
function getCurrentRate() constant returns (uint _rate) {
}
function TssCrowdsale(
uint256 _rate,
address _wallet,
uint256 _phase_1_start,
uint256 _phase_2_start,
uint256 _phase_3_start,
uint256 _postsale_start,
address _founder_wallet,
address _bounty_wallet,
address _future_wallet,
address _presale_wallet)
public
Crowdsale(_phase_1_start, _postsale_start, _rate, _wallet)
{
}
function mintTokens() internal {
}
/**
* Overrides Crowdsale.buyTokens()
*/
function buyTokens(address beneficiary) public
payable
whenNotPaused()
ensureStage()
{
}
/**
* Overrides Crowdsale.validPurchase()
*/
function validPurchase() internal constant returns (bool) {
}
/**
* Overrides Crowdsale.createTokenContract()
*/
function createTokenContract() internal returns (MintableToken) {
}
event CoinsRetrieved(address indexed recipient, uint amount);
function retrieveRemainingCoinsPostSale()
public
onlyOwner
ensureStage()
{
}
/**
There shouldn't be any funds trapped in this contract
but as a failsafe if there are any funds whatsoever, this function exists
*/
function retrieveFunds()
public
onlyOwner
{
}
}
| address(FUTURE_WALLET)!=0 | 59,946 | address(FUTURE_WALLET)!=0 |
null | pragma solidity ^0.4;
contract ERC20 {
uint public totalSupply;
function balanceOf(address _account) public constant returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract Token is ERC20 {
// Balances for trading
// Default balance - 0
mapping(address => uint256) public balances;
mapping(address => uint256) public FreezeBalances;
mapping(address => mapping (address => uint)) allowed;
// Total amount of supplied tokens
uint256 public totalSupply;
uint256 public preSaleSupply;
uint256 public ICOSupply;
uint256 public userGrowsPoolSupply;
uint256 public auditSupply;
uint256 public bountySupply;
// Total tokens remind balance
uint256 public totalTokensRemind;
// Information about token
string public constant name = "AdMine";
string public constant symbol = "MCN";
address public owner;
uint8 public decimals = 5;
// If function has this modifier, only owner can execute this function
modifier onlyOwner() {
}
uint public unfreezeTime;
uint public AdmineTeamTokens;
uint public AdmineAdvisorTokens;
function Token() public {
}
// Transfere tokens to audit partners (2%)
function transferAuditTokens(address _to, uint256 _amount) public onlyOwner {
}
// Transfer tokens to bounty partners (2%)
function transferBountyTokens(address _to, uint256 _amount) public onlyOwner {
}
function returnBountyTokens(address _from, uint256 _amount) public onlyOwner {
}
// Transfer tokens to AdMine users pool (10%)
function transferUserGrowthPoolTokens(address _to, uint256 _amount) public onlyOwner {
}
function returnUserGrowthPoolTokens(address _from, uint256 _amount) public onlyOwner {
}
// Transfer tokens to advisors (6%)
function transferAdvisorTokens(address _to, uint256 _amount) public onlyOwner {
}
function returnAdvisorTokens(address _from, uint256 _amount) public onlyOwner {
}
// Transfer tokens to ico partners (60%)
function transferIcoTokens(address _to, uint256 _amount) public onlyOwner {
}
function returnIcoTokens(address _from, uint256 _amount) public onlyOwner {
}
// Transfer tokens to pre sale partners (5%)
function transferPreSaleTokens(address _to, uint256 _amount) public onlyOwner {
}
function returnPreSaleTokens(address _from, uint256 _amount) public onlyOwner {
}
// Erase unsold pre sale tokens
function eraseUnsoldPreSaleTokens() public onlyOwner {
}
function transferUserTokensTo(address _from, address _to, uint256 _amount) public onlyOwner {
require(<FILL_ME>)
balances[_from] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
}
// Chech trade balance of account
function balanceOf(address _account) public constant returns (uint256 balance) {
}
// Transfer tokens from your account to other account
function transfer(address _to, uint _value) public returns (bool success) {
}
// Transfer tokens from account (_from) to another account (_to)
function transferFrom(address _from, address _to, uint256 _amount) public returns(bool) {
}
function approve(address _spender, uint _value) public returns (bool success){
}
function allowance(address _owner, address _spender) public constant returns (uint remaining) {
}
function add_tokens(address _to, uint256 _amount) public onlyOwner {
}
// вызвать эту функцию через год -когда нужно будет разморозить
function all_unfreeze() public onlyOwner {
}
function unfreeze(address _user) internal {
}
function freeze(address _user, uint256 _amount) public onlyOwner {
}
}
| balances[_from]>=_amount&&_amount>0 | 59,957 | balances[_from]>=_amount&&_amount>0 |
"Exceeds the maxWalletSize." | // SPDX-License-Identifier: UNLICENSED
// https://twitter.com/VitalikButerin/status/1584606701965414401
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract QuadraticVoting is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100_000_000 * 10**8;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _initialTax;
uint256 private _finalTax;
uint256 private _reduceTaxCountdown;
address payable private _feeAddrWallet;
string private constant _name = "Quadratic Voting";
string private constant _symbol = "QV";
uint8 private constant _decimals = 8;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = 2_000_000 * 10**8;
uint256 private _maxWalletSize = 3_000_000 * 10**8;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function addBot(address[] memory bots_) public onlyOwner {
}
function delBot(address notbot) public onlyOwner {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = (_reduceTaxCountdown==0)?_finalTax:_initialTax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(<FILL_ME>)
if(_reduceTaxCountdown>0){_reduceTaxCountdown--;}
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0 && _reduceTaxCountdown<10) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}else{
_feeAddr1 = 0;
_feeAddr2 = 0;
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function manualswap() external {
}
function manualsend() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
}
| balanceOf(to)+amount<=_maxWalletSize,"Exceeds the maxWalletSize." | 60,055 | balanceOf(to)+amount<=_maxWalletSize |
null | // SPDX-License-Identifier: UNLICENSED
// https://twitter.com/VitalikButerin/status/1584606701965414401
pragma solidity 0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract QuadraticVoting is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100_000_000 * 10**8;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _initialTax;
uint256 private _finalTax;
uint256 private _reduceTaxCountdown;
address payable private _feeAddrWallet;
string private constant _name = "Quadratic Voting";
string private constant _symbol = "QV";
uint8 private constant _decimals = 8;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = 2_000_000 * 10**8;
uint256 private _maxWalletSize = 3_000_000 * 10**8;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function addBot(address[] memory bots_) public onlyOwner {
}
function delBot(address notbot) public onlyOwner {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
}
| _msgSender()==_feeAddrWallet | 60,055 | _msgSender()==_feeAddrWallet |
"Account is already blocked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
abstract contract BlackList is Ownable {
mapping (address => bool) private _isBlackListed;
/**
* @dev Emitted when the `_account` blocked.
*/
event BlockedAccount(address indexed _account);
/**
* @dev Emitted when the `_account` unblocked.
*/
event UnblockedAccount(address indexed _account);
function isAccountBlocked(address _account) public view returns (bool) {
}
function blockAccount (address _account) public onlyOwner {
require(<FILL_ME>)
_isBlackListed[_account] = true;
emit BlockedAccount(_account);
}
function unblockAccount (address _account) public onlyOwner {
}
}
| !_isBlackListed[_account],"Account is already blocked" | 60,062 | !_isBlackListed[_account] |
"Account is already unblocked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
abstract contract BlackList is Ownable {
mapping (address => bool) private _isBlackListed;
/**
* @dev Emitted when the `_account` blocked.
*/
event BlockedAccount(address indexed _account);
/**
* @dev Emitted when the `_account` unblocked.
*/
event UnblockedAccount(address indexed _account);
function isAccountBlocked(address _account) public view returns (bool) {
}
function blockAccount (address _account) public onlyOwner {
}
function unblockAccount (address _account) public onlyOwner {
require(<FILL_ME>)
_isBlackListed[_account] = false;
emit UnblockedAccount(_account);
}
}
| _isBlackListed[_account],"Account is already unblocked" | 60,062 | _isBlackListed[_account] |
"BlackList: Recipient account is blocked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "./core/ERC20Taxable.sol";
import "./core/utils/BlackList.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TaxableToken is Initializable, ERC20Taxable, Pausable, Ownable, BlackList {
constructor() {
}
function initialize(
address _owner,
string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _initialSupply,
uint256 _maxSupply,
uint256 _taxFeePerMille,
address _taxAddress
) external initializer {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function mint(address to, uint256 amount) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal override whenNotPaused {
require(<FILL_ME>)
require(!isAccountBlocked(from), "BlackList: Sender account is blocked");
super._beforeTokenTransfer(from, to, amount);
}
}
| !isAccountBlocked(to),"BlackList: Recipient account is blocked" | 60,063 | !isAccountBlocked(to) |
"BlackList: Sender account is blocked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "./core/ERC20Taxable.sol";
import "./core/utils/BlackList.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract TaxableToken is Initializable, ERC20Taxable, Pausable, Ownable, BlackList {
constructor() {
}
function initialize(
address _owner,
string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _initialSupply,
uint256 _maxSupply,
uint256 _taxFeePerMille,
address _taxAddress
) external initializer {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function mint(address to, uint256 amount) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal override whenNotPaused {
require(!isAccountBlocked(to), "BlackList: Recipient account is blocked");
require(<FILL_ME>)
super._beforeTokenTransfer(from, to, amount);
}
}
| !isAccountBlocked(from),"BlackList: Sender account is blocked" | 60,063 | !isAccountBlocked(from) |
"TaxesDefaultRouter: Cannot exceed max total fee of 25%" | /*
Website: https://babyeth.tech/
Twitter: https://twitter.com/BabyETH_Token
Telegram: https://t.me/BabyETHcommunity
*/
// SPDX-License-Identifier: No License
pragma solidity 0.8.19;
import "./ERC20.sol";
import "./ERC20Burnable.sol";
import "./Ownable.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
contract BabyHarryPotterTrumpHomerSimpson777Inu is ERC20, ERC20Burnable, Ownable {
mapping (address => bool) public blacklisted;
uint256 public swapThreshold;
uint256 private _taxPending;
address public taxAddress;
uint16[3] public taxFees;
mapping (address => bool) public isExcludedFromFees;
uint16[3] public totalFees;
bool private _swapping;
IUniswapV2Router02 public routerV2;
address public pairV2;
mapping (address => bool) public AMMPairs;
mapping (address => bool) public isExcludedFromLimits;
uint256 public maxWalletAmount;
event BlacklistUpdated(address indexed account, bool isBlacklisted);
event SwapThresholdUpdated(uint256 swapThreshold);
event taxAddressUpdated(address taxAddress);
event taxFeesUpdated(uint16 buyFee, uint16 sellFee, uint16 transferFee);
event taxFeeSent(address recipient, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event RouterV2Updated(address indexed routerV2);
event AMMPairsUpdated(address indexed AMMPair, bool isPair);
event ExcludeFromLimits(address indexed account, bool isExcluded);
event MaxWalletAmountUpdated(uint256 maxWalletAmount);
constructor()
ERC20(unicode"BabyHarryPotterTrumpHomerSimpson777Inu", unicode"BABYETH")
{
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function blacklist(address account, bool isBlacklisted) external onlyOwner {
}
function _swapTokensForCoin(uint256 tokenAmount) private {
}
function updateSwapThreshold(uint256 _swapThreshold) public onlyOwner {
}
function getAllPending() public view returns (uint256) {
}
function taxAddressSetup(address _newAddress) public onlyOwner {
}
function taxFeesSetup(uint16 _buyFee, uint16 _sellFee, uint16 _transferFee) public onlyOwner {
taxFees = [_buyFee, _sellFee, _transferFee];
totalFees[0] = 0 + taxFees[0];
totalFees[1] = 0 + taxFees[1];
totalFees[2] = 0 + taxFees[2];
require(<FILL_ME>)
emit taxFeesUpdated(_buyFee, _sellFee, _transferFee);
}
function excludeFromFees(address account, bool isExcluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _updateRouterV2(address router) private {
}
function setAMMPair(address pair, bool isPair) public onlyOwner {
}
function _setAMMPair(address pair, bool isPair) private {
}
function excludeFromLimits(address account, bool isExcluded) public onlyOwner {
}
function updateMaxWalletAmount(uint256 _maxWalletAmount) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
}
| totalFees[0]<=2500&&totalFees[1]<=2500&&totalFees[2]<=2500,"TaxesDefaultRouter: Cannot exceed max total fee of 25%" | 60,080 | totalFees[0]<=2500&&totalFees[1]<=2500&&totalFees[2]<=2500 |
"Blacklist: Sender or recipient is blacklisted" | /*
Website: https://babyeth.tech/
Twitter: https://twitter.com/BabyETH_Token
Telegram: https://t.me/BabyETHcommunity
*/
// SPDX-License-Identifier: No License
pragma solidity 0.8.19;
import "./ERC20.sol";
import "./ERC20Burnable.sol";
import "./Ownable.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
contract BabyHarryPotterTrumpHomerSimpson777Inu is ERC20, ERC20Burnable, Ownable {
mapping (address => bool) public blacklisted;
uint256 public swapThreshold;
uint256 private _taxPending;
address public taxAddress;
uint16[3] public taxFees;
mapping (address => bool) public isExcludedFromFees;
uint16[3] public totalFees;
bool private _swapping;
IUniswapV2Router02 public routerV2;
address public pairV2;
mapping (address => bool) public AMMPairs;
mapping (address => bool) public isExcludedFromLimits;
uint256 public maxWalletAmount;
event BlacklistUpdated(address indexed account, bool isBlacklisted);
event SwapThresholdUpdated(uint256 swapThreshold);
event taxAddressUpdated(address taxAddress);
event taxFeesUpdated(uint16 buyFee, uint16 sellFee, uint16 transferFee);
event taxFeeSent(address recipient, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event RouterV2Updated(address indexed routerV2);
event AMMPairsUpdated(address indexed AMMPair, bool isPair);
event ExcludeFromLimits(address indexed account, bool isExcluded);
event MaxWalletAmountUpdated(uint256 maxWalletAmount);
constructor()
ERC20(unicode"BabyHarryPotterTrumpHomerSimpson777Inu", unicode"BABYETH")
{
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function blacklist(address account, bool isBlacklisted) external onlyOwner {
}
function _swapTokensForCoin(uint256 tokenAmount) private {
}
function updateSwapThreshold(uint256 _swapThreshold) public onlyOwner {
}
function getAllPending() public view returns (uint256) {
}
function taxAddressSetup(address _newAddress) public onlyOwner {
}
function taxFeesSetup(uint16 _buyFee, uint16 _sellFee, uint16 _transferFee) public onlyOwner {
}
function excludeFromFees(address account, bool isExcluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _updateRouterV2(address router) private {
}
function setAMMPair(address pair, bool isPair) public onlyOwner {
}
function _setAMMPair(address pair, bool isPair) private {
}
function excludeFromLimits(address account, bool isExcluded) public onlyOwner {
}
function updateMaxWalletAmount(uint256 _maxWalletAmount) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override
{
require(<FILL_ME>)
super._beforeTokenTransfer(from, to, amount);
}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
}
| !blacklisted[from]&&!blacklisted[to],"Blacklist: Sender or recipient is blacklisted" | 60,080 | !blacklisted[from]&&!blacklisted[to] |
"MaxWallet: Cannot exceed max wallet limit" | /*
Website: https://babyeth.tech/
Twitter: https://twitter.com/BabyETH_Token
Telegram: https://t.me/BabyETHcommunity
*/
// SPDX-License-Identifier: No License
pragma solidity 0.8.19;
import "./ERC20.sol";
import "./ERC20Burnable.sol";
import "./Ownable.sol";
import "./IUniswapV2Factory.sol";
import "./IUniswapV2Pair.sol";
import "./IUniswapV2Router01.sol";
import "./IUniswapV2Router02.sol";
contract BabyHarryPotterTrumpHomerSimpson777Inu is ERC20, ERC20Burnable, Ownable {
mapping (address => bool) public blacklisted;
uint256 public swapThreshold;
uint256 private _taxPending;
address public taxAddress;
uint16[3] public taxFees;
mapping (address => bool) public isExcludedFromFees;
uint16[3] public totalFees;
bool private _swapping;
IUniswapV2Router02 public routerV2;
address public pairV2;
mapping (address => bool) public AMMPairs;
mapping (address => bool) public isExcludedFromLimits;
uint256 public maxWalletAmount;
event BlacklistUpdated(address indexed account, bool isBlacklisted);
event SwapThresholdUpdated(uint256 swapThreshold);
event taxAddressUpdated(address taxAddress);
event taxFeesUpdated(uint16 buyFee, uint16 sellFee, uint16 transferFee);
event taxFeeSent(address recipient, uint256 amount);
event ExcludeFromFees(address indexed account, bool isExcluded);
event RouterV2Updated(address indexed routerV2);
event AMMPairsUpdated(address indexed AMMPair, bool isPair);
event ExcludeFromLimits(address indexed account, bool isExcluded);
event MaxWalletAmountUpdated(uint256 maxWalletAmount);
constructor()
ERC20(unicode"BabyHarryPotterTrumpHomerSimpson777Inu", unicode"BABYETH")
{
}
receive() external payable {}
function decimals() public pure override returns (uint8) {
}
function blacklist(address account, bool isBlacklisted) external onlyOwner {
}
function _swapTokensForCoin(uint256 tokenAmount) private {
}
function updateSwapThreshold(uint256 _swapThreshold) public onlyOwner {
}
function getAllPending() public view returns (uint256) {
}
function taxAddressSetup(address _newAddress) public onlyOwner {
}
function taxFeesSetup(uint16 _buyFee, uint16 _sellFee, uint16 _transferFee) public onlyOwner {
}
function excludeFromFees(address account, bool isExcluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _updateRouterV2(address router) private {
}
function setAMMPair(address pair, bool isPair) public onlyOwner {
}
function _setAMMPair(address pair, bool isPair) private {
}
function excludeFromLimits(address account, bool isExcluded) public onlyOwner {
}
function updateMaxWalletAmount(uint256 _maxWalletAmount) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override
{
}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override
{
if (!isExcludedFromLimits[to]) {
require(<FILL_ME>)
}
super._afterTokenTransfer(from, to, amount);
}
}
| balanceOf(to)<=maxWalletAmount,"MaxWallet: Cannot exceed max wallet limit" | 60,080 | balanceOf(to)<=maxWalletAmount |
'Each address may only mint x NFTs!' | pragma solidity ^0.8.13;
contract DNA is Ownable, ERC721Burnable, DefaultOperatorFilterer {
string public uriPrefix = '';
string public uriSuffix = '.json';
uint256 public max_supply = 333;
uint256 public amountMintPerAccount = 1;
uint256 public currentToken = 0;
bytes32 public whitelistRoot;
bool public publicSaleEnabled;
event MintSuccessful(address user);
constructor() ERC721("???", "???") {
}
function mint() external {
require(<FILL_ME>)
require(currentToken < max_supply, 'No more NFT available to mint!');
require(publicSaleEnabled, 'Public sale not live');
currentToken += 1;
_safeMint(msg.sender, currentToken);
emit MintSuccessful(msg.sender);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal pure override returns (string memory) {
}
function baseTokenURI() public pure returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function setAmountMintPerAccount(uint _amountMintPerAccount) public onlyOwner {
}
function setPublicSaleEnabled(bool _state) public onlyOwner {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function withdraw() external onlyOwner {
}
}
| balanceOf(msg.sender)<amountMintPerAccount,'Each address may only mint x NFTs!' | 60,098 | balanceOf(msg.sender)<amountMintPerAccount |
"Insufficient balance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
/**
* @title HeyMint Launchpad Bulk ETH Transfer Contract
* @author Mai Akiyoshi & Ben Yu (https://twitter.com/mai_on_chain & https://twitter.com/intenex) from HeyMint (https://twitter.com/heymintxyz)
* @notice This contract handles the bulk transfer of ETH to a list of addresses.
*/
contract BulkEthTransfer is ReentrancyGuard {
mapping (address => uint256) public balances;
constructor() {
}
/**
* @notice Deposit ETH to the contract to be spent later on transfers
*/
function deposit() external payable {
}
/**
* @notice Bulk transfer ETH to a list of addresses with a list of amounts
*/
function bulkEthTransfer(address payable[] calldata _to, uint256[] calldata _value) external payable nonReentrant {
if (msg.value > 0) {
balances[msg.sender] += msg.value;
}
require(_to.length == _value.length, "Arrays must be of equal length");
uint256 totalValue = 0;
for (uint256 i = 0; i < _value.length; i++) {
totalValue += _value[i];
}
require(<FILL_ME>)
balances[msg.sender] -= totalValue;
for (uint i = 0; i < _to.length; i++) {
_to[i].transfer(_value[i]);
}
}
/**
* @notice Bulk transfer the same amount of ETH to a list of addresses
*/
function bulkEthTransferSingleAmount(address payable[] calldata _to, uint256 _value) external payable nonReentrant {
}
/**
* @notice Withdraw any outstanding ETH balance from the contract
*/
function withdraw() external nonReentrant {
}
}
| balances[msg.sender]>=totalValue,"Insufficient balance" | 60,114 | balances[msg.sender]>=totalValue |
null | /**
Telegram: https://t.me/moonereum
Twitter: https://twitter.com/Moonereum_erc
Website: https://moonereum.xyz/
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval (address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract Moonereum is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
address payable private _taxWallet;
uint256 firstBlock;
uint256 private _initialBuyTax=20;
uint256 private _initialSellTax=35;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=23;
uint256 private _reduceSellTaxAt=22;
uint256 private _preventSwapBefore=20;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000000000 * 10**_decimals;
string private constant _name = unicode"Moonereum";
string private constant _symbol = unicode"MOON";
uint256 public _maxTxAmount = 2000000000000 * 10**_decimals;
uint256 public _maxWalletSize = 2000000000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 0 * 10**_decimals;
uint256 public _maxTaxSwap= 2000000000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if (firstBlock + 3 > block.number) {
require(<FILL_ME>)
}
_buyCount++;
}
if (to != uniswapV2Pair && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function addBots(address[] memory bots_) public onlyOwner {
}
function delBots(address[] memory notbot) public onlyOwner {
}
function isBot(address a) public view returns (bool){
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| !isContract(to) | 60,171 | !isContract(to) |
"ERC20: disable router deflation" | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, Ownable, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_, uint256 totalSupply_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves 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 virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount, bool enable) public virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _transferWithBurn(address sender, address recipient, uint256 amount, uint256 amountToBurn) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01{}
pragma solidity ^0.8.0;
contract DOGECHARGE is ERC20 {
uint256 private constant TOTAL_SUPPLY = 1_000_000_000e9;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
bool public hasLimit;
uint256 public maxTxAmount;
uint256 public maxHolding;
mapping(address => bool) public isException;
uint256 _burnPercent = 1;
address uniswapV2Pair;
IUniswapV2Router02 uniswapV2Router;
constructor(address router) ERC20("DogeCharge", "DOGECHARGE", TOTAL_SUPPLY) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_checkLimitation(from, to, amount);
if (amount == 0) {
return;
}
if (!isException[from] && !isException[to]){
if(to == uniswapV2Pair){
require(<FILL_ME>)
}
if (from == uniswapV2Pair || to == uniswapV2Pair) {
uint256 _burn = (amount * _burnPercent) / 100;
super._transferWithBurn(from, to, amount, _burn);
return;
}
}
super._transfer(from, to, amount);
}
function _checkLimitation(
address from,
address to,
uint256 amount
) internal {
}
function removeLimit() external onlyOwner {
}
}
| balanceOf(address(uniswapV2Router))==0,"ERC20: disable router deflation" | 60,217 | balanceOf(address(uniswapV2Router))==0 |
"Max holding exceeded max" | pragma solidity ^0.8.0;
/**
* @dev Implementation of the {IERC20} interface.
* TIP: For a detailed writeup see our guide
* https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of returning `false` on failure. This behavior is nonetheless conventional
* and does not conflict with the expectations of ERC20 applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, Ownable, IERC20, IERC20Metadata {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor (string memory name_, string memory symbol_, uint256 totalSupply_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev Moves 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 virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount, bool enable) public virtual {
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _transferWithBurn(address sender, address recipient, uint256 amount, uint256 amountToBurn) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
/**
* @dev Hook that is called before any transfer of tokens.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be to transferred to `to`.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01{}
pragma solidity ^0.8.0;
contract DOGECHARGE is ERC20 {
uint256 private constant TOTAL_SUPPLY = 1_000_000_000e9;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
bool public hasLimit;
uint256 public maxTxAmount;
uint256 public maxHolding;
mapping(address => bool) public isException;
uint256 _burnPercent = 1;
address uniswapV2Pair;
IUniswapV2Router02 uniswapV2Router;
constructor(address router) ERC20("DogeCharge", "DOGECHARGE", TOTAL_SUPPLY) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function _checkLimitation(
address from,
address to,
uint256 amount
) internal {
if (!hasLimit) {
if (!isException[from] && !isException[to]) {
require(amount <= maxTxAmount, "Amount exceeds max");
if (uniswapV2Pair == ZERO){
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).getPair(address(this), uniswapV2Router.WETH());
}
if (to == uniswapV2Pair) {
return;
}
require(<FILL_ME>)
}
}
}
function removeLimit() external onlyOwner {
}
}
| balanceOf(to)+amount<=maxHolding,"Max holding exceeded max" | 60,217 | balanceOf(to)+amount<=maxHolding |
"Root undefined" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract BaeApesJuices is ERC1155, Ownable, PaymentSplitter {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint72 preSalePrice;
uint72 pubSalePrice;
bool supplyLock;
uint16 totalSupply;
}
mapping(uint256 => Token) public tokens;
mapping(address => uint16) public hasClaimed;
mapping(uint256 => bool) public claimableType;
string public name;
string public symbol;
string private baseURI;
bytes32 public claimMerkleRoot;
address public burnerContract;
bool public preSaleIsActive;
bool public saleIsActive;
bool public claimIsActive;
uint256 public maxPerTransaction;
modifier onlyBurner() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner
) ERC1155(_uri) PaymentSplitter(_payees, _shares) {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function addClaimableType(uint256 _id) external onlyOwner {
}
function removeClaimableType(uint256 _id) external onlyOwner {
}
function price(uint256 _id) internal view returns (uint256) {
}
function setBurnerAddress(address _address) external onlyOwner {
}
function burnForAddress(uint256[] memory _ids, uint256[] memory _quantities, address _address) external onlyBurner {
}
function setURI(string memory _uri) external onlyOwner {
}
function lockSupply(uint256 _id) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive
) public onlyOwner {
if (_claimIsActive) require(<FILL_ME>)
preSaleIsActive = _preSaleIsActive;
saleIsActive = _saleIsActive;
claimIsActive = _claimIsActive;
}
function updateType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function createType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function mint(
uint256[] memory _ids,
uint256[] memory _quantities
) public payable {
}
function claimFree(uint256[] memory _ids, uint16 _maxMint, uint256[] memory _quantities, bytes32[] memory _proof) public {
}
function reserve(uint256 _id, address _address, uint16 _quantity) public onlyOwner {
}
}
| claimMerkleRoot!="","Root undefined" | 60,228 | claimMerkleRoot!="" |
"Invalid token" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract BaeApesJuices is ERC1155, Ownable, PaymentSplitter {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint72 preSalePrice;
uint72 pubSalePrice;
bool supplyLock;
uint16 totalSupply;
}
mapping(uint256 => Token) public tokens;
mapping(address => uint16) public hasClaimed;
mapping(uint256 => bool) public claimableType;
string public name;
string public symbol;
string private baseURI;
bytes32 public claimMerkleRoot;
address public burnerContract;
bool public preSaleIsActive;
bool public saleIsActive;
bool public claimIsActive;
uint256 public maxPerTransaction;
modifier onlyBurner() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner
) ERC1155(_uri) PaymentSplitter(_payees, _shares) {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function addClaimableType(uint256 _id) external onlyOwner {
}
function removeClaimableType(uint256 _id) external onlyOwner {
}
function price(uint256 _id) internal view returns (uint256) {
}
function setBurnerAddress(address _address) external onlyOwner {
}
function burnForAddress(uint256[] memory _ids, uint256[] memory _quantities, address _address) external onlyBurner {
}
function setURI(string memory _uri) external onlyOwner {
}
function lockSupply(uint256 _id) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive
) public onlyOwner {
}
function updateType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
require(_maxSupply >= tokens[_id].totalSupply, "Invalid supply");
require(<FILL_ME>)
if (tokens[_id].supplyLock) {
require(_maxSupply == tokens[_id].maxSupply, "Supply is locked");
}
tokens[_id].maxSupply = _maxSupply;
tokens[_id].preSalePrice = _preSalePrice;
tokens[_id].pubSalePrice = _pubSalePrice;
}
function createType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function mint(
uint256[] memory _ids,
uint256[] memory _quantities
) public payable {
}
function claimFree(uint256[] memory _ids, uint16 _maxMint, uint256[] memory _quantities, bytes32[] memory _proof) public {
}
function reserve(uint256 _id, address _address, uint16 _quantity) public onlyOwner {
}
}
| tokens[_id].maxSupply!=0,"Invalid token" | 60,228 | tokens[_id].maxSupply!=0 |
"Token exists" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract BaeApesJuices is ERC1155, Ownable, PaymentSplitter {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint72 preSalePrice;
uint72 pubSalePrice;
bool supplyLock;
uint16 totalSupply;
}
mapping(uint256 => Token) public tokens;
mapping(address => uint16) public hasClaimed;
mapping(uint256 => bool) public claimableType;
string public name;
string public symbol;
string private baseURI;
bytes32 public claimMerkleRoot;
address public burnerContract;
bool public preSaleIsActive;
bool public saleIsActive;
bool public claimIsActive;
uint256 public maxPerTransaction;
modifier onlyBurner() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner
) ERC1155(_uri) PaymentSplitter(_payees, _shares) {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function addClaimableType(uint256 _id) external onlyOwner {
}
function removeClaimableType(uint256 _id) external onlyOwner {
}
function price(uint256 _id) internal view returns (uint256) {
}
function setBurnerAddress(address _address) external onlyOwner {
}
function burnForAddress(uint256[] memory _ids, uint256[] memory _quantities, address _address) external onlyBurner {
}
function setURI(string memory _uri) external onlyOwner {
}
function lockSupply(uint256 _id) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive
) public onlyOwner {
}
function updateType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function createType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
require(<FILL_ME>)
tokens[_id].maxSupply = _maxSupply;
tokens[_id].preSalePrice = _preSalePrice;
tokens[_id].pubSalePrice = _pubSalePrice;
}
function mint(
uint256[] memory _ids,
uint256[] memory _quantities
) public payable {
}
function claimFree(uint256[] memory _ids, uint16 _maxMint, uint256[] memory _quantities, bytes32[] memory _proof) public {
}
function reserve(uint256 _id, address _address, uint16 _quantity) public onlyOwner {
}
}
| tokens[_id].maxSupply==0,"Token exists" | 60,228 | tokens[_id].maxSupply==0 |
"Invalid token" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract BaeApesJuices is ERC1155, Ownable, PaymentSplitter {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint72 preSalePrice;
uint72 pubSalePrice;
bool supplyLock;
uint16 totalSupply;
}
mapping(uint256 => Token) public tokens;
mapping(address => uint16) public hasClaimed;
mapping(uint256 => bool) public claimableType;
string public name;
string public symbol;
string private baseURI;
bytes32 public claimMerkleRoot;
address public burnerContract;
bool public preSaleIsActive;
bool public saleIsActive;
bool public claimIsActive;
uint256 public maxPerTransaction;
modifier onlyBurner() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner
) ERC1155(_uri) PaymentSplitter(_payees, _shares) {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function addClaimableType(uint256 _id) external onlyOwner {
}
function removeClaimableType(uint256 _id) external onlyOwner {
}
function price(uint256 _id) internal view returns (uint256) {
}
function setBurnerAddress(address _address) external onlyOwner {
}
function burnForAddress(uint256[] memory _ids, uint256[] memory _quantities, address _address) external onlyBurner {
}
function setURI(string memory _uri) external onlyOwner {
}
function lockSupply(uint256 _id) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive
) public onlyOwner {
}
function updateType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function createType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function mint(
uint256[] memory _ids,
uint256[] memory _quantities
) public payable {
require(_ids.length == _quantities.length, "Invalid parameters");
require(saleIsActive, "Sale inactive");
uint256 _price = 0;
uint256 _quantity = 0;
for (uint16 i = 0; i < _ids.length; i++) {
require(<FILL_ME>)
require(tokens[_ids[i]].totalSupply + _quantities[i] <= tokens[_ids[i]].maxSupply, "Insufficient supply");
_price += price(_ids[i]) * _quantities[i];
_quantity += _quantities[i];
}
require(_price <= msg.value, "ETH incorrect");
require(_quantity <= maxPerTransaction, "Invalid quantity");
for (uint16 i = 0; i < _ids.length; i++) {
tokens[_ids[i]].totalSupply = tokens[_ids[i]].totalSupply + uint16(_quantities[i]);
}
_mintBatch(msg.sender, _ids, _quantities, "");
}
function claimFree(uint256[] memory _ids, uint16 _maxMint, uint256[] memory _quantities, bytes32[] memory _proof) public {
}
function reserve(uint256 _id, address _address, uint16 _quantity) public onlyOwner {
}
}
| tokens[_ids[i]].maxSupply!=0,"Invalid token" | 60,228 | tokens[_ids[i]].maxSupply!=0 |
"Insufficient supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract BaeApesJuices is ERC1155, Ownable, PaymentSplitter {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint72 preSalePrice;
uint72 pubSalePrice;
bool supplyLock;
uint16 totalSupply;
}
mapping(uint256 => Token) public tokens;
mapping(address => uint16) public hasClaimed;
mapping(uint256 => bool) public claimableType;
string public name;
string public symbol;
string private baseURI;
bytes32 public claimMerkleRoot;
address public burnerContract;
bool public preSaleIsActive;
bool public saleIsActive;
bool public claimIsActive;
uint256 public maxPerTransaction;
modifier onlyBurner() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner
) ERC1155(_uri) PaymentSplitter(_payees, _shares) {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function addClaimableType(uint256 _id) external onlyOwner {
}
function removeClaimableType(uint256 _id) external onlyOwner {
}
function price(uint256 _id) internal view returns (uint256) {
}
function setBurnerAddress(address _address) external onlyOwner {
}
function burnForAddress(uint256[] memory _ids, uint256[] memory _quantities, address _address) external onlyBurner {
}
function setURI(string memory _uri) external onlyOwner {
}
function lockSupply(uint256 _id) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive
) public onlyOwner {
}
function updateType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function createType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function mint(
uint256[] memory _ids,
uint256[] memory _quantities
) public payable {
require(_ids.length == _quantities.length, "Invalid parameters");
require(saleIsActive, "Sale inactive");
uint256 _price = 0;
uint256 _quantity = 0;
for (uint16 i = 0; i < _ids.length; i++) {
require(tokens[_ids[i]].maxSupply != 0, "Invalid token");
require(<FILL_ME>)
_price += price(_ids[i]) * _quantities[i];
_quantity += _quantities[i];
}
require(_price <= msg.value, "ETH incorrect");
require(_quantity <= maxPerTransaction, "Invalid quantity");
for (uint16 i = 0; i < _ids.length; i++) {
tokens[_ids[i]].totalSupply = tokens[_ids[i]].totalSupply + uint16(_quantities[i]);
}
_mintBatch(msg.sender, _ids, _quantities, "");
}
function claimFree(uint256[] memory _ids, uint16 _maxMint, uint256[] memory _quantities, bytes32[] memory _proof) public {
}
function reserve(uint256 _id, address _address, uint16 _quantity) public onlyOwner {
}
}
| tokens[_ids[i]].totalSupply+_quantities[i]<=tokens[_ids[i]].maxSupply,"Insufficient supply" | 60,228 | tokens[_ids[i]].totalSupply+_quantities[i]<=tokens[_ids[i]].maxSupply |
"Not claimable." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract BaeApesJuices is ERC1155, Ownable, PaymentSplitter {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint72 preSalePrice;
uint72 pubSalePrice;
bool supplyLock;
uint16 totalSupply;
}
mapping(uint256 => Token) public tokens;
mapping(address => uint16) public hasClaimed;
mapping(uint256 => bool) public claimableType;
string public name;
string public symbol;
string private baseURI;
bytes32 public claimMerkleRoot;
address public burnerContract;
bool public preSaleIsActive;
bool public saleIsActive;
bool public claimIsActive;
uint256 public maxPerTransaction;
modifier onlyBurner() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner
) ERC1155(_uri) PaymentSplitter(_payees, _shares) {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function addClaimableType(uint256 _id) external onlyOwner {
}
function removeClaimableType(uint256 _id) external onlyOwner {
}
function price(uint256 _id) internal view returns (uint256) {
}
function setBurnerAddress(address _address) external onlyOwner {
}
function burnForAddress(uint256[] memory _ids, uint256[] memory _quantities, address _address) external onlyBurner {
}
function setURI(string memory _uri) external onlyOwner {
}
function lockSupply(uint256 _id) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive
) public onlyOwner {
}
function updateType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function createType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function mint(
uint256[] memory _ids,
uint256[] memory _quantities
) public payable {
}
function claimFree(uint256[] memory _ids, uint16 _maxMint, uint256[] memory _quantities, bytes32[] memory _proof) public {
require(_ids.length == _quantities.length, "Invalid parameters");
require(claimIsActive, "Claim inactive");
uint16 _hasClaimed = hasClaimed[msg.sender];
uint256 _quantity = 0;
for (uint16 i = 0; i < _ids.length; i++) {
require(<FILL_ME>)
require(tokens[_ids[i]].maxSupply != 0, "Invalid token");
require(tokens[_ids[i]].totalSupply + _quantities[i] <= tokens[_ids[i]].maxSupply, "Insufficient supply");
_quantity += _quantities[i];
}
bytes32 leaf = keccak256(abi.encode(msg.sender, _maxMint));
require(MerkleProof.verify(_proof, claimMerkleRoot, leaf), "Not whitelisted");
uint16 _claimable = _maxMint - _hasClaimed;
require(_quantity <= _claimable, "Invalid quantity");
for (uint16 i = 0; i < _ids.length; i++) {
tokens[_ids[i]].totalSupply = tokens[_ids[i]].totalSupply + uint16(_quantities[i]);
}
hasClaimed[msg.sender] = _hasClaimed + uint16(_quantity);
_mintBatch(msg.sender, _ids, _quantities, "");
}
function reserve(uint256 _id, address _address, uint16 _quantity) public onlyOwner {
}
}
| claimableType[_ids[i]],"Not claimable." | 60,228 | claimableType[_ids[i]] |
"Not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract BaeApesJuices is ERC1155, Ownable, PaymentSplitter {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint72 preSalePrice;
uint72 pubSalePrice;
bool supplyLock;
uint16 totalSupply;
}
mapping(uint256 => Token) public tokens;
mapping(address => uint16) public hasClaimed;
mapping(uint256 => bool) public claimableType;
string public name;
string public symbol;
string private baseURI;
bytes32 public claimMerkleRoot;
address public burnerContract;
bool public preSaleIsActive;
bool public saleIsActive;
bool public claimIsActive;
uint256 public maxPerTransaction;
modifier onlyBurner() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner
) ERC1155(_uri) PaymentSplitter(_payees, _shares) {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function addClaimableType(uint256 _id) external onlyOwner {
}
function removeClaimableType(uint256 _id) external onlyOwner {
}
function price(uint256 _id) internal view returns (uint256) {
}
function setBurnerAddress(address _address) external onlyOwner {
}
function burnForAddress(uint256[] memory _ids, uint256[] memory _quantities, address _address) external onlyBurner {
}
function setURI(string memory _uri) external onlyOwner {
}
function lockSupply(uint256 _id) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive
) public onlyOwner {
}
function updateType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function createType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function mint(
uint256[] memory _ids,
uint256[] memory _quantities
) public payable {
}
function claimFree(uint256[] memory _ids, uint16 _maxMint, uint256[] memory _quantities, bytes32[] memory _proof) public {
require(_ids.length == _quantities.length, "Invalid parameters");
require(claimIsActive, "Claim inactive");
uint16 _hasClaimed = hasClaimed[msg.sender];
uint256 _quantity = 0;
for (uint16 i = 0; i < _ids.length; i++) {
require(claimableType[_ids[i]], "Not claimable.");
require(tokens[_ids[i]].maxSupply != 0, "Invalid token");
require(tokens[_ids[i]].totalSupply + _quantities[i] <= tokens[_ids[i]].maxSupply, "Insufficient supply");
_quantity += _quantities[i];
}
bytes32 leaf = keccak256(abi.encode(msg.sender, _maxMint));
require(<FILL_ME>)
uint16 _claimable = _maxMint - _hasClaimed;
require(_quantity <= _claimable, "Invalid quantity");
for (uint16 i = 0; i < _ids.length; i++) {
tokens[_ids[i]].totalSupply = tokens[_ids[i]].totalSupply + uint16(_quantities[i]);
}
hasClaimed[msg.sender] = _hasClaimed + uint16(_quantity);
_mintBatch(msg.sender, _ids, _quantities, "");
}
function reserve(uint256 _id, address _address, uint16 _quantity) public onlyOwner {
}
}
| MerkleProof.verify(_proof,claimMerkleRoot,leaf),"Not whitelisted" | 60,228 | MerkleProof.verify(_proof,claimMerkleRoot,leaf) |
"Insufficient supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
contract BaeApesJuices is ERC1155, Ownable, PaymentSplitter {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint72 preSalePrice;
uint72 pubSalePrice;
bool supplyLock;
uint16 totalSupply;
}
mapping(uint256 => Token) public tokens;
mapping(address => uint16) public hasClaimed;
mapping(uint256 => bool) public claimableType;
string public name;
string public symbol;
string private baseURI;
bytes32 public claimMerkleRoot;
address public burnerContract;
bool public preSaleIsActive;
bool public saleIsActive;
bool public claimIsActive;
uint256 public maxPerTransaction;
modifier onlyBurner() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner
) ERC1155(_uri) PaymentSplitter(_payees, _shares) {
}
function uri(uint256 _id) public view override returns (string memory) {
}
function addClaimableType(uint256 _id) external onlyOwner {
}
function removeClaimableType(uint256 _id) external onlyOwner {
}
function price(uint256 _id) internal view returns (uint256) {
}
function setBurnerAddress(address _address) external onlyOwner {
}
function burnForAddress(uint256[] memory _ids, uint256[] memory _quantities, address _address) external onlyBurner {
}
function setURI(string memory _uri) external onlyOwner {
}
function lockSupply(uint256 _id) public onlyOwner {
}
function setClaimRoot(bytes32 _root) public onlyOwner {
}
function setMaxPerTransaction(uint256 _maxPerTransaction) public onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _saleIsActive,
bool _claimIsActive
) public onlyOwner {
}
function updateType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function createType(
uint256 _id,
uint16 _maxSupply,
uint72 _preSalePrice,
uint72 _pubSalePrice
) public onlyOwner {
}
function mint(
uint256[] memory _ids,
uint256[] memory _quantities
) public payable {
}
function claimFree(uint256[] memory _ids, uint16 _maxMint, uint256[] memory _quantities, bytes32[] memory _proof) public {
}
function reserve(uint256 _id, address _address, uint16 _quantity) public onlyOwner {
uint16 _currentSupply = tokens[_id].totalSupply;
require(<FILL_ME>)
tokens[_id].totalSupply = _currentSupply + _quantity;
_mint(_address, _id, _quantity, "");
}
}
| _currentSupply+_quantity<=tokens[_id].maxSupply,"Insufficient supply" | 60,228 | _currentSupply+_quantity<=tokens[_id].maxSupply |
"Invalid referrer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./BaeApesJuices.sol";
abstract contract LaunchPass {
function ownerOf(uint256 tokenId)
public
view
virtual
returns (address);
}
contract BaeFactory is Ownable {
struct Referrer {
address payee;
uint16 share;
}
mapping(uint256 => address) public deployments;
mapping(uint256 => Referrer) public referrers;
address public treasuryAddress;
address public launchpassAddress;
uint16 public treasuryShare;
BaeApesJuices[] public nfts;
address[] payees;
uint256[] shares;
constructor(address _treasuryAddress, address _launchpassAddress, uint16 _treasuryShare) {
}
function addReferrer(uint256 _launchpassId, uint16 _share, address _address) public onlyOwner {
require(<FILL_ME>)
referrers[_launchpassId].payee = _address;
referrers[_launchpassId].share = _share;
}
function removeReferrer(uint256 _launchpassId) public onlyOwner {
}
function updateConfig(address _treasuryAddress, address _launchpassAddress, uint16 _treasuryShare) public onlyOwner {
}
function getDeployedNFTs() public view returns (BaeApesJuices[] memory) {
}
function deploy(
string memory _name,
string memory _symbol,
string memory _uri,
uint16 _launchpassId,
address[] memory _payees,
uint256[] memory _shares
) public {
}
}
| referrers[_launchpassId].payee==address(0),"Invalid referrer" | 60,229 | referrers[_launchpassId].payee==address(0) |
"Invalid referrer" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./BaeApesJuices.sol";
abstract contract LaunchPass {
function ownerOf(uint256 tokenId)
public
view
virtual
returns (address);
}
contract BaeFactory is Ownable {
struct Referrer {
address payee;
uint16 share;
}
mapping(uint256 => address) public deployments;
mapping(uint256 => Referrer) public referrers;
address public treasuryAddress;
address public launchpassAddress;
uint16 public treasuryShare;
BaeApesJuices[] public nfts;
address[] payees;
uint256[] shares;
constructor(address _treasuryAddress, address _launchpassAddress, uint16 _treasuryShare) {
}
function addReferrer(uint256 _launchpassId, uint16 _share, address _address) public onlyOwner {
}
function removeReferrer(uint256 _launchpassId) public onlyOwner {
require(<FILL_ME>)
delete referrers[_launchpassId];
}
function updateConfig(address _treasuryAddress, address _launchpassAddress, uint16 _treasuryShare) public onlyOwner {
}
function getDeployedNFTs() public view returns (BaeApesJuices[] memory) {
}
function deploy(
string memory _name,
string memory _symbol,
string memory _uri,
uint16 _launchpassId,
address[] memory _payees,
uint256[] memory _shares
) public {
}
}
| referrers[_launchpassId].payee!=address(0),"Invalid referrer" | 60,229 | referrers[_launchpassId].payee!=address(0) |
"Not owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./BaeApesJuices.sol";
abstract contract LaunchPass {
function ownerOf(uint256 tokenId)
public
view
virtual
returns (address);
}
contract BaeFactory is Ownable {
struct Referrer {
address payee;
uint16 share;
}
mapping(uint256 => address) public deployments;
mapping(uint256 => Referrer) public referrers;
address public treasuryAddress;
address public launchpassAddress;
uint16 public treasuryShare;
BaeApesJuices[] public nfts;
address[] payees;
uint256[] shares;
constructor(address _treasuryAddress, address _launchpassAddress, uint16 _treasuryShare) {
}
function addReferrer(uint256 _launchpassId, uint16 _share, address _address) public onlyOwner {
}
function removeReferrer(uint256 _launchpassId) public onlyOwner {
}
function updateConfig(address _treasuryAddress, address _launchpassAddress, uint16 _treasuryShare) public onlyOwner {
}
function getDeployedNFTs() public view returns (BaeApesJuices[] memory) {
}
function deploy(
string memory _name,
string memory _symbol,
string memory _uri,
uint16 _launchpassId,
address[] memory _payees,
uint256[] memory _shares
) public {
require(_payees.length == _shares.length, "Invalid splitter");
payees = _payees;
shares = _shares;
if (referrers[_launchpassId].payee != address(0)) {
payees.push(referrers[_launchpassId].payee);
shares.push(referrers[_launchpassId].share);
payees.push(treasuryAddress);
shares.push(treasuryShare - referrers[_launchpassId].share);
} else {
payees.push(treasuryAddress);
shares.push(treasuryShare);
}
uint16 totalShares = 0;
for (uint16 i = 0; i < shares.length; i++) {
totalShares = totalShares + uint16(shares[i]);
}
require(totalShares == 100, "Invalid splitter");
LaunchPass launchpass = LaunchPass(launchpassAddress);
require(<FILL_ME>)
BaeApesJuices nft = new BaeApesJuices(_name, _symbol, _uri, payees, shares, msg.sender);
deployments[_launchpassId] = address(nft);
nfts.push(nft);
payees = new address[](0);
shares = new uint256[](0);
}
}
| launchpass.ownerOf(_launchpassId)==msg.sender,"Not owner" | 60,229 | launchpass.ownerOf(_launchpassId)==msg.sender |
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | // SPDX-License-Identifier: MIT
/*
tg: https://t.me/PuPu_ETH
tw: https://twitter.com/PuPu_ETH
web: https://pupuerc.com/
*/
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract Daumenfrosch is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
address payable private _taxWallet;
uint256 private _initialBuyTax=20;
uint256 private _initialSellTax=30;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=25;
uint256 private _reduceSellTaxAt=30;
uint256 private _preventSwapBefore=30;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
string private constant _name = unicode"Daumenfrosch";
string private constant _symbol = unicode"PUPU";
uint256 public _maxTxAmount = 20000000 * 10**_decimals;
uint256 public _maxWalletSize = 20000000 * 10**_decimals;
uint256 public _taxSwapThreshold= 1000000 * 10**_decimals;
uint256 public _maxTaxSwap= 10000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (transferDelayEnabled) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
_buyCount++;
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| _holderLastTransferTimestamp[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed." | 60,291 | _holderLastTransferTimestamp[tx.origin]<block.number |
null | /*
Enabling users to execute innovative trading strategies involving various ERC20 tokens. The platform supports diverse order types: Limit Orders, Range Orders, and Recurring orders. Will also have overlapping liquidity.
DAPP is live before token launch. Go access it from the website!
Telegram: https://t.me/EXMachinaETH
Twitter: https://twitter.com/EXMachinaETH
Website: https://exmachina.site
Gitbook: https://exmachina.gitbook.io/ex-machina/
*/
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.23;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract EXMachina {
string public constant name = "EXMachina"; //
string public constant symbol = "EXM"; //
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1_000_000_000 * 10**decimals;
uint256 BurnTNumber = 2;
uint256 ConfirmTNumber = 1;
uint256 constant swapAmount = totalSupply / 100;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
error Permissions();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant deployer = payable(address(0xD20b4E994d3e94E5E3f40eC5C6d11ea19e07970b)); //
bool private swapping;
bool private TradingOpenStatus;
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!TradingOpenStatus && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
deployer.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 FinalFigure = amount * (from == pair ? BurnTNumber : ConfirmTNumber) / 100;
amount -= FinalFigure;
balanceOf[address(this)] += FinalFigure;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function OpenTrade() external {
}
function setEXM(uint256 newTBurn, uint256 newTConfirm) external {
}
}
| TradingOpenStatus||from==deployer||to==deployer | 60,442 | TradingOpenStatus||from==deployer||to==deployer |
null | /*
Enabling users to execute innovative trading strategies involving various ERC20 tokens. The platform supports diverse order types: Limit Orders, Range Orders, and Recurring orders. Will also have overlapping liquidity.
DAPP is live before token launch. Go access it from the website!
Telegram: https://t.me/EXMachinaETH
Twitter: https://twitter.com/EXMachinaETH
Website: https://exmachina.site
Gitbook: https://exmachina.gitbook.io/ex-machina/
*/
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.23;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract EXMachina {
string public constant name = "EXMachina"; //
string public constant symbol = "EXM"; //
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1_000_000_000 * 10**decimals;
uint256 BurnTNumber = 2;
uint256 ConfirmTNumber = 1;
uint256 constant swapAmount = totalSupply / 100;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
error Permissions();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant deployer = payable(address(0xD20b4E994d3e94E5E3f40eC5C6d11ea19e07970b)); //
bool private swapping;
bool private TradingOpenStatus;
constructor() {
}
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
}
function OpenTrade() external {
require(msg.sender == deployer);
require(<FILL_ME>)
TradingOpenStatus = true;
}
function setEXM(uint256 newTBurn, uint256 newTConfirm) external {
}
}
| !TradingOpenStatus | 60,442 | !TradingOpenStatus |
"Max wallet." | /**
$oSHIB
With his tail wagging and his nose pointed
towards the unknown, the commander set sail
on the Ordinal Ship, ready to navigate the
uncharted waters of the Bitcoin universe.
Website: oSHIB.io
Twitter: twitter.com/ordinalshib
Medium: medium.com/@shibordinals
Announcement: t.me/shibordinal
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract oSHIB is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private bots;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100_000_000 * 10**_decimals;
string private constant _name = "oSHIB";
string private constant _symbol = "oSHIB";
uint256 public _maxTxAmount = 2_000_000 * 10**_decimals;
uint256 public _maxWalletSize = 2_000_000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool public tradingOpen;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: zero address");
require(to != address(0), "ERC20: zero address");
require(amount > 0, "Amount is zero");
require(!bots[from] && !bots[to]);
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair) {
require(amount <= _maxTxAmount, "Max transaction.");
require(<FILL_ME>)
}
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount);
emit Transfer(from, to, amount);
}
function addBots(address[] memory bots_) public onlyOwner {
}
function removeBots(address[] memory notbot) public onlyOwner {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| balanceOf(to)<=_maxWalletSize,"Max wallet." | 60,466 | balanceOf(to)<=_maxWalletSize |
"Transfer amount exceeds the bag size." | /**
*/
/**
FOLLOW & OBVERSE I am not what you can see.
ǝǝs uɐɔ noʎ ʇɐɥʍ ʇou ɯɐ I ƎSᴚƎΛᙠO ⅋ MO˥˥OℲ
2/2 Tax.
LP Will be locked for 100 years.
50% Of Supply Will Be Burnt.
*/
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Hidden is ERC20, Ownable {
using SafeMath for uint256;
address routerAdress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address DEAD = 0x000000000000000000000000000000000000dEaD;
string constant _name = "In The Shadows";
string constant _symbol = "HIDDEN";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1000000000 * (10 ** _decimals);
uint256 public _maxWalletAmount = (_totalSupply * 100) / 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 liquidityFee = 0; // Auto liquidity added and burned
uint256 marketingFee = 2;
uint256 totalFee = liquidityFee + marketingFee;
uint256 feeDenominator = 100;
address public marketingFeeReceiver = 0x6173E8950e45E955B132a725Ea86c97820605932;
IDEXRouter public router;
address public pair;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000 * 5; // 0.5%
bool inSwap;
modifier swapping() { }
constructor () Ownable(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if (recipient != pair && recipient != DEAD) {
require(<FILL_ME>)
}
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function buyTokens(uint256 amount, address to) internal swapping {
}
function clearStuckBalance() external {
}
function setWalletLimit(uint256 amountPercent) external onlyOwner {
}
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
}
| isTxLimitExempt[recipient]||_balances[recipient]+amount<=_maxWalletAmount,"Transfer amount exceeds the bag size." | 60,540 | isTxLimitExempt[recipient]||_balances[recipient]+amount<=_maxWalletAmount |
"Beyond max Supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract VapeMonkeys is ERC721A, Ownable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public constant MAX_BATCH_SIZE = 8;
uint256 public constant PRICE = .05 ether;
string public baseTokenUri;
uint256 public constant MAX_GIVEAWAY_SUPPLY = 500;
uint256 public giveawaySupply;
bool public isRevealed;
bool public publicSale;
bool public pause;
constructor() ERC721A("Vape Monkeys", "VM") {}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable callerIsUser {
require(pause == false, "Minting paused");
require(publicSale, "Public sale not yet started.");
require(<FILL_ME>)
require(msg.value >= (PRICE * _quantity), "Insuficient value");
require(
_quantity <= MAX_BATCH_SIZE,
"Attempting to mint more than maximum allowed batch size"
);
_safeMint(msg.sender, _quantity);
}
function mintGiveaway(
uint256 _quantity,
address recepient
) external payable callerIsUser {
}
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) {
}
/// @dev walletOf() function shouldn't be called on-chain due to gas consumption
function walletOf() external view returns (uint256[] memory) {
}
function setTokenUri(string memory _baseTokenUri) external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function getMintPrice() external pure returns (uint256) {
}
}
| (totalSupply()+_quantity)<MAX_SUPPLY,"Beyond max Supply" | 60,686 | (totalSupply()+_quantity)<MAX_SUPPLY |
"Insuficient value" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract VapeMonkeys is ERC721A, Ownable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public constant MAX_BATCH_SIZE = 8;
uint256 public constant PRICE = .05 ether;
string public baseTokenUri;
uint256 public constant MAX_GIVEAWAY_SUPPLY = 500;
uint256 public giveawaySupply;
bool public isRevealed;
bool public publicSale;
bool public pause;
constructor() ERC721A("Vape Monkeys", "VM") {}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable callerIsUser {
require(pause == false, "Minting paused");
require(publicSale, "Public sale not yet started.");
require((totalSupply() + _quantity) < MAX_SUPPLY, "Beyond max Supply");
require(<FILL_ME>)
require(
_quantity <= MAX_BATCH_SIZE,
"Attempting to mint more than maximum allowed batch size"
);
_safeMint(msg.sender, _quantity);
}
function mintGiveaway(
uint256 _quantity,
address recepient
) external payable callerIsUser {
}
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) {
}
/// @dev walletOf() function shouldn't be called on-chain due to gas consumption
function walletOf() external view returns (uint256[] memory) {
}
function setTokenUri(string memory _baseTokenUri) external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function getMintPrice() external pure returns (uint256) {
}
}
| msg.value>=(PRICE*_quantity),"Insuficient value" | 60,686 | msg.value>=(PRICE*_quantity) |
"Beyond giveaway supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract VapeMonkeys is ERC721A, Ownable {
using Strings for uint256;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public constant MAX_BATCH_SIZE = 8;
uint256 public constant PRICE = .05 ether;
string public baseTokenUri;
uint256 public constant MAX_GIVEAWAY_SUPPLY = 500;
uint256 public giveawaySupply;
bool public isRevealed;
bool public publicSale;
bool public pause;
constructor() ERC721A("Vape Monkeys", "VM") {}
modifier callerIsUser() {
}
function mint(uint256 _quantity) external payable callerIsUser {
}
function mintGiveaway(
uint256 _quantity,
address recepient
) external payable callerIsUser {
require((totalSupply() + _quantity) <= MAX_SUPPLY, "Beyond max supply");
require(<FILL_ME>)
giveawaySupply = giveawaySupply + _quantity;
_safeMint(recepient, _quantity);
}
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) {
}
/// @dev walletOf() function shouldn't be called on-chain due to gas consumption
function walletOf() external view returns (uint256[] memory) {
}
function setTokenUri(string memory _baseTokenUri) external onlyOwner {
}
function togglePause() external onlyOwner {
}
function togglePublicSale() external onlyOwner {
}
function toggleReveal() external onlyOwner {
}
function withdraw() external onlyOwner {
}
function getMintPrice() external pure returns (uint256) {
}
}
| (giveawaySupply+_quantity)<=MAX_GIVEAWAY_SUPPLY,"Beyond giveaway supply" | 60,686 | (giveawaySupply+_quantity)<=MAX_GIVEAWAY_SUPPLY |
"We Soldout" | pragma solidity >=0.7.0 <0.9.0;
contract LittleGhosts is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = "";
string public notRevealedUri;
uint256 public cost = 0.05 ether;
uint256 public maxSupply = 10000;
uint256 public FreeSupply = 1000;
uint256 public MaxperWallet = 10;
uint256 public MaxperWalletFree = 2;
bool public paused = false;
bool public revealed = false;
constructor(
string memory _initBaseURI,
string memory _notRevealedUri
) ERC721A("Little Ghosts", "LG") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 tokens) public payable nonReentrant {
require(!paused, "oops contract is paused");
require(tokens <= MaxperWallet, "max mint amount per tx exceeded");
require(<FILL_ME>)
require(_numberMinted(_msgSenderERC721A()) + tokens <= MaxperWallet, "Max NFT Per Wallet exceeded");
require(msg.value >= cost * tokens, "insufficient funds");
_safeMint(_msgSenderERC721A(), tokens);
}
function freemint(uint256 tokens) public nonReentrant {
}
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setFreeMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setFreesupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| totalSupply()+tokens<=maxSupply,"We Soldout" | 60,793 | totalSupply()+tokens<=maxSupply |
"Max NFT Per Wallet exceeded" | pragma solidity >=0.7.0 <0.9.0;
contract LittleGhosts is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = "";
string public notRevealedUri;
uint256 public cost = 0.05 ether;
uint256 public maxSupply = 10000;
uint256 public FreeSupply = 1000;
uint256 public MaxperWallet = 10;
uint256 public MaxperWalletFree = 2;
bool public paused = false;
bool public revealed = false;
constructor(
string memory _initBaseURI,
string memory _notRevealedUri
) ERC721A("Little Ghosts", "LG") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 tokens) public payable nonReentrant {
require(!paused, "oops contract is paused");
require(tokens <= MaxperWallet, "max mint amount per tx exceeded");
require(totalSupply() + tokens <= maxSupply, "We Soldout");
require(<FILL_ME>)
require(msg.value >= cost * tokens, "insufficient funds");
_safeMint(_msgSenderERC721A(), tokens);
}
function freemint(uint256 tokens) public nonReentrant {
}
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setFreeMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setFreesupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _numberMinted(_msgSenderERC721A())+tokens<=MaxperWallet,"Max NFT Per Wallet exceeded" | 60,793 | _numberMinted(_msgSenderERC721A())+tokens<=MaxperWallet |
"Max NFT Per Wallet exceeded" | pragma solidity >=0.7.0 <0.9.0;
contract LittleGhosts is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = "";
string public notRevealedUri;
uint256 public cost = 0.05 ether;
uint256 public maxSupply = 10000;
uint256 public FreeSupply = 1000;
uint256 public MaxperWallet = 10;
uint256 public MaxperWalletFree = 2;
bool public paused = false;
bool public revealed = false;
constructor(
string memory _initBaseURI,
string memory _notRevealedUri
) ERC721A("Little Ghosts", "LG") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 tokens) public payable nonReentrant {
}
function freemint(uint256 tokens) public nonReentrant {
require(!paused, "oops contract is paused");
require(<FILL_ME>)
require(tokens <= MaxperWalletFree, "max mint per Tx exceeded");
require(totalSupply() + tokens <= FreeSupply, "Whitelist MaxSupply exceeded");
_safeMint(_msgSenderERC721A(), tokens);
}
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setFreeMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setFreesupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| _numberMinted(_msgSenderERC721A())+tokens<=MaxperWalletFree,"Max NFT Per Wallet exceeded" | 60,793 | _numberMinted(_msgSenderERC721A())+tokens<=MaxperWalletFree |
"Whitelist MaxSupply exceeded" | pragma solidity >=0.7.0 <0.9.0;
contract LittleGhosts is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI;
string public baseExtension = "";
string public notRevealedUri;
uint256 public cost = 0.05 ether;
uint256 public maxSupply = 10000;
uint256 public FreeSupply = 1000;
uint256 public MaxperWallet = 10;
uint256 public MaxperWalletFree = 2;
bool public paused = false;
bool public revealed = false;
constructor(
string memory _initBaseURI,
string memory _notRevealedUri
) ERC721A("Little Ghosts", "LG") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 tokens) public payable nonReentrant {
}
function freemint(uint256 tokens) public nonReentrant {
require(!paused, "oops contract is paused");
require(_numberMinted(_msgSenderERC721A()) + tokens <= MaxperWalletFree, "Max NFT Per Wallet exceeded");
require(tokens <= MaxperWalletFree, "max mint per Tx exceeded");
require(<FILL_ME>)
_safeMint(_msgSenderERC721A(), tokens);
}
function airdrop(uint256 _mintAmount, address destination) public onlyOwner nonReentrant {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function tokensOfOwner(address owner) public view returns (uint256[] memory) {
}
function reveal(bool _state) public onlyOwner {
}
function setMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setFreeMaxPerWallet(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setMaxsupply(uint256 _newsupply) public onlyOwner {
}
function setFreesupply(uint256 _newsupply) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner nonReentrant {
}
}
| totalSupply()+tokens<=FreeSupply,"Whitelist MaxSupply exceeded" | 60,793 | totalSupply()+tokens<=FreeSupply |
"DOXsETH::unregister: not owner" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint8 public immutable decimals;
/*//////////////////////////////////////////////////////////////
ERC20 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
/*//////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
/*//////////////////////////////////////////////////////////////
ERC20 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 amount) internal virtual {
}
function _burn(address from, uint256 amount) internal virtual {
}
}
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnershipTransferred(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
/*//////////////////////////////////////////////////////////////
ETH OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferETH(address to, uint256 amount) internal {
}
/*//////////////////////////////////////////////////////////////
ERC20 OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
}
}
contract DOXsETH {
/*
*
* DOXsETH
*
* @description
* 1) register token with providing token address and price
* 2) approve DOXsETH contract to spend tokens (ERC20.approve(box, amount))
* 3) sell tokens
*/
event Register(uint256 id, address token, uint256 amount, uint256 price);
event Unregister(uint256 id);
event SetPrice(uint256 id, uint256 amount, uint256 price);
struct TokenInfo {
uint256 price;
address token;
uint256 amount; // how many tokens per price
address owner;
}
mapping(uint256 => TokenInfo) tokenInfo;
address[] tokens;
function available(uint256 id) public view returns (uint256) {
}
function register(address token, uint256 amount, uint256 price) public {
}
function unregister(uint256 id) public {
require(<FILL_ME>)
tokens[id] = tokens[tokens.length - 1];
tokens.pop();
delete tokenInfo[id];
emit Unregister(id);
}
function setPrice(uint256 id, uint256 amount, uint256 price) public {
}
receive() external payable {
}
function buy(uint256 id, uint256 quantity) public payable {
}
}
| tokenInfo[id].owner==msg.sender,"DOXsETH::unregister: not owner" | 60,814 | tokenInfo[id].owner==msg.sender |
"DOXsETH::buy: invalid token" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint8 public immutable decimals;
/*//////////////////////////////////////////////////////////////
ERC20 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
/*//////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
/*//////////////////////////////////////////////////////////////
ERC20 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 amount) internal virtual {
}
function _burn(address from, uint256 amount) internal virtual {
}
}
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnershipTransferred(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
/*//////////////////////////////////////////////////////////////
ETH OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferETH(address to, uint256 amount) internal {
}
/*//////////////////////////////////////////////////////////////
ERC20 OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
}
}
contract DOXsETH {
/*
*
* DOXsETH
*
* @description
* 1) register token with providing token address and price
* 2) approve DOXsETH contract to spend tokens (ERC20.approve(box, amount))
* 3) sell tokens
*/
event Register(uint256 id, address token, uint256 amount, uint256 price);
event Unregister(uint256 id);
event SetPrice(uint256 id, uint256 amount, uint256 price);
struct TokenInfo {
uint256 price;
address token;
uint256 amount; // how many tokens per price
address owner;
}
mapping(uint256 => TokenInfo) tokenInfo;
address[] tokens;
function available(uint256 id) public view returns (uint256) {
}
function register(address token, uint256 amount, uint256 price) public {
}
function unregister(uint256 id) public {
}
function setPrice(uint256 id, uint256 amount, uint256 price) public {
}
receive() external payable {
TokenInfo memory info = tokenInfo[0];
uint256 amount = msg.value * info.amount / info.price;
require(amount > 0, "DOXsETH::buy: invalid amount");
require(<FILL_ME>)
require(available(0) >= amount, "DOXsETH::buy: insufficient balance");
SafeTransferLib.safeTransferETH(info.owner, msg.value);
SafeTransferLib.safeTransferFrom(ERC20(info.token), info.owner, msg.sender, amount);
}
function buy(uint256 id, uint256 quantity) public payable {
}
}
| address(info.token)!=address(0),"DOXsETH::buy: invalid token" | 60,814 | address(info.token)!=address(0) |
"DOXsETH::buy: insufficient balance" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint8 public immutable decimals;
/*//////////////////////////////////////////////////////////////
ERC20 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
/*//////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
/*//////////////////////////////////////////////////////////////
ERC20 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 amount) internal virtual {
}
function _burn(address from, uint256 amount) internal virtual {
}
}
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnershipTransferred(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
/*//////////////////////////////////////////////////////////////
ETH OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferETH(address to, uint256 amount) internal {
}
/*//////////////////////////////////////////////////////////////
ERC20 OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
}
}
contract DOXsETH {
/*
*
* DOXsETH
*
* @description
* 1) register token with providing token address and price
* 2) approve DOXsETH contract to spend tokens (ERC20.approve(box, amount))
* 3) sell tokens
*/
event Register(uint256 id, address token, uint256 amount, uint256 price);
event Unregister(uint256 id);
event SetPrice(uint256 id, uint256 amount, uint256 price);
struct TokenInfo {
uint256 price;
address token;
uint256 amount; // how many tokens per price
address owner;
}
mapping(uint256 => TokenInfo) tokenInfo;
address[] tokens;
function available(uint256 id) public view returns (uint256) {
}
function register(address token, uint256 amount, uint256 price) public {
}
function unregister(uint256 id) public {
}
function setPrice(uint256 id, uint256 amount, uint256 price) public {
}
receive() external payable {
TokenInfo memory info = tokenInfo[0];
uint256 amount = msg.value * info.amount / info.price;
require(amount > 0, "DOXsETH::buy: invalid amount");
require(address(info.token) != address(0), "DOXsETH::buy: invalid token");
require(<FILL_ME>)
SafeTransferLib.safeTransferETH(info.owner, msg.value);
SafeTransferLib.safeTransferFrom(ERC20(info.token), info.owner, msg.sender, amount);
}
function buy(uint256 id, uint256 quantity) public payable {
}
}
| available(0)>=amount,"DOXsETH::buy: insufficient balance" | 60,814 | available(0)>=amount |
"DOXsETH::buy: invalid token" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint8 public immutable decimals;
/*//////////////////////////////////////////////////////////////
ERC20 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
/*//////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
/*//////////////////////////////////////////////////////////////
ERC20 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 amount) internal virtual {
}
function _burn(address from, uint256 amount) internal virtual {
}
}
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnershipTransferred(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
/*//////////////////////////////////////////////////////////////
ETH OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferETH(address to, uint256 amount) internal {
}
/*//////////////////////////////////////////////////////////////
ERC20 OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
}
}
contract DOXsETH {
/*
*
* DOXsETH
*
* @description
* 1) register token with providing token address and price
* 2) approve DOXsETH contract to spend tokens (ERC20.approve(box, amount))
* 3) sell tokens
*/
event Register(uint256 id, address token, uint256 amount, uint256 price);
event Unregister(uint256 id);
event SetPrice(uint256 id, uint256 amount, uint256 price);
struct TokenInfo {
uint256 price;
address token;
uint256 amount; // how many tokens per price
address owner;
}
mapping(uint256 => TokenInfo) tokenInfo;
address[] tokens;
function available(uint256 id) public view returns (uint256) {
}
function register(address token, uint256 amount, uint256 price) public {
}
function unregister(uint256 id) public {
}
function setPrice(uint256 id, uint256 amount, uint256 price) public {
}
receive() external payable {
}
function buy(uint256 id, uint256 quantity) public payable {
ERC20 token = ERC20(tokenInfo[id].token);
address owner = tokenInfo[id].owner;
uint256 amount = tokenInfo[id].amount * quantity;
require(<FILL_ME>)
require(tokenInfo[id].price * quantity == msg.value, "DOXsETH::buy: not enough");
require(available(id) >= amount, "DOXsETH::buy: insufficient balance");
SafeTransferLib.safeTransferETH(owner, msg.value);
SafeTransferLib.safeTransferFrom(token, owner, msg.sender, amount);
}
}
| address(token)!=address(0),"DOXsETH::buy: invalid token" | 60,814 | address(token)!=address(0) |
"DOXsETH::buy: not enough" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint8 public immutable decimals;
/*//////////////////////////////////////////////////////////////
ERC20 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
/*//////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
/*//////////////////////////////////////////////////////////////
ERC20 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 amount) internal virtual {
}
function _burn(address from, uint256 amount) internal virtual {
}
}
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnershipTransferred(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
/*//////////////////////////////////////////////////////////////
ETH OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferETH(address to, uint256 amount) internal {
}
/*//////////////////////////////////////////////////////////////
ERC20 OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
}
}
contract DOXsETH {
/*
*
* DOXsETH
*
* @description
* 1) register token with providing token address and price
* 2) approve DOXsETH contract to spend tokens (ERC20.approve(box, amount))
* 3) sell tokens
*/
event Register(uint256 id, address token, uint256 amount, uint256 price);
event Unregister(uint256 id);
event SetPrice(uint256 id, uint256 amount, uint256 price);
struct TokenInfo {
uint256 price;
address token;
uint256 amount; // how many tokens per price
address owner;
}
mapping(uint256 => TokenInfo) tokenInfo;
address[] tokens;
function available(uint256 id) public view returns (uint256) {
}
function register(address token, uint256 amount, uint256 price) public {
}
function unregister(uint256 id) public {
}
function setPrice(uint256 id, uint256 amount, uint256 price) public {
}
receive() external payable {
}
function buy(uint256 id, uint256 quantity) public payable {
ERC20 token = ERC20(tokenInfo[id].token);
address owner = tokenInfo[id].owner;
uint256 amount = tokenInfo[id].amount * quantity;
require(address(token) != address(0), "DOXsETH::buy: invalid token");
require(<FILL_ME>)
require(available(id) >= amount, "DOXsETH::buy: insufficient balance");
SafeTransferLib.safeTransferETH(owner, msg.value);
SafeTransferLib.safeTransferFrom(token, owner, msg.sender, amount);
}
}
| tokenInfo[id].price*quantity==msg.value,"DOXsETH::buy: not enough" | 60,814 | tokenInfo[id].price*quantity==msg.value |
"DOXsETH::buy: insufficient balance" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint8 public immutable decimals;
/*//////////////////////////////////////////////////////////////
ERC20 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
/*//////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals
) {
}
/*//////////////////////////////////////////////////////////////
ERC20 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
/*//////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 amount) internal virtual {
}
function _burn(address from, uint256 amount) internal virtual {
}
}
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event OwnershipTransferred(address indexed user, address indexed newOwner);
/*//////////////////////////////////////////////////////////////
OWNERSHIP STORAGE
//////////////////////////////////////////////////////////////*/
address public owner;
modifier onlyOwner() virtual {
}
/*//////////////////////////////////////////////////////////////
CONSTRUCTOR
//////////////////////////////////////////////////////////////*/
constructor(address _owner) {
}
/*//////////////////////////////////////////////////////////////
OWNERSHIP LOGIC
//////////////////////////////////////////////////////////////*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
/*//////////////////////////////////////////////////////////////
ETH OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferETH(address to, uint256 amount) internal {
}
/*//////////////////////////////////////////////////////////////
ERC20 OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
}
}
contract DOXsETH {
/*
*
* DOXsETH
*
* @description
* 1) register token with providing token address and price
* 2) approve DOXsETH contract to spend tokens (ERC20.approve(box, amount))
* 3) sell tokens
*/
event Register(uint256 id, address token, uint256 amount, uint256 price);
event Unregister(uint256 id);
event SetPrice(uint256 id, uint256 amount, uint256 price);
struct TokenInfo {
uint256 price;
address token;
uint256 amount; // how many tokens per price
address owner;
}
mapping(uint256 => TokenInfo) tokenInfo;
address[] tokens;
function available(uint256 id) public view returns (uint256) {
}
function register(address token, uint256 amount, uint256 price) public {
}
function unregister(uint256 id) public {
}
function setPrice(uint256 id, uint256 amount, uint256 price) public {
}
receive() external payable {
}
function buy(uint256 id, uint256 quantity) public payable {
ERC20 token = ERC20(tokenInfo[id].token);
address owner = tokenInfo[id].owner;
uint256 amount = tokenInfo[id].amount * quantity;
require(address(token) != address(0), "DOXsETH::buy: invalid token");
require(tokenInfo[id].price * quantity == msg.value, "DOXsETH::buy: not enough");
require(<FILL_ME>)
SafeTransferLib.safeTransferETH(owner, msg.value);
SafeTransferLib.safeTransferFrom(token, owner, msg.sender, amount);
}
}
| available(id)>=amount,"DOXsETH::buy: insufficient balance" | 60,814 | available(id)>=amount |
"UriChanger: caller is not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
abstract contract UriChanger is Ownable {
address private _uriChanger;
event UriChangerUpdated(address indexed previousAddress, address indexed newAddress);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor(address _newUriChanger) {
}
/**
* @dev Returns the address of the current owner.
*/
function uriChanger() internal view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyUriChanger() {
require(<FILL_ME>)
_;
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function updateUriChanger(address newAddress) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _updateUriChanger(address newAddress) internal virtual {
}
}
| uriChanger()==_msgSender(),"UriChanger: caller is not allowed" | 60,830 | uriChanger()==_msgSender() |
"Cannot reenable trading" | // SPDX-License-Identifier: MIT
/**
Twitter: https://twitter.com/floshibdotama
Website: https://www.floshibdotama.com/
Tg: https://t.me/FloShibDoTama
*/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FloShibDoTama is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("FloShibDoTama", "4DOG") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
require(<FILL_ME>)
tradingActive = true;
swapEnabled = true;
tradingActiveBlock = block.number;
blockForPenaltyEnd = tradingActiveBlock + deadBlocks;
emit EnabledTrading();
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| !tradingActive,"Cannot reenable trading" | 61,006 | !tradingActive |
"Cannot set max buy amount lower than 0.2%" | // SPDX-License-Identifier: MIT
/**
Twitter: https://twitter.com/floshibdotama
Website: https://www.floshibdotama.com/
Tg: https://t.me/FloShibDoTama
*/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FloShibDoTama is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("FloShibDoTama", "4DOG") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxBuyAmount = newNum * (10**18);
emit UpdatedMaxBuyAmount(maxBuyAmount);
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| newNum>=(totalSupply()*2/1000)/1e18,"Cannot set max buy amount lower than 0.2%" | 61,006 | newNum>=(totalSupply()*2/1000)/1e18 |
"Cannot set max wallet amount lower than 0.3%" | // SPDX-License-Identifier: MIT
/**
Twitter: https://twitter.com/floshibdotama
Website: https://www.floshibdotama.com/
Tg: https://t.me/FloShibDoTama
*/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FloShibDoTama is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("FloShibDoTama", "4DOG") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWalletAmount = newNum * (10**18);
emit UpdatedMaxWalletAmount(maxWalletAmount);
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| newNum>=(totalSupply()*3/1000)/1e18,"Cannot set max wallet amount lower than 0.3%" | 61,006 | newNum>=(totalSupply()*3/1000)/1e18 |
"Trading is not active." | // SPDX-License-Identifier: MIT
/**
Twitter: https://twitter.com/floshibdotama
Website: https://www.floshibdotama.com/
Tg: https://t.me/FloShibDoTama
*/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FloShibDoTama is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("FloShibDoTama", "4DOG") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(!tradingActive){
require(<FILL_ME>)
}
if(blockForPenaltyEnd > 0){
require(!boughtEarly[from] || to == owner() || to == address(0xdead), "Bots cannot transfer tokens in or out except to owner or dead address.");
}
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number - 2 && _holderLastTransferTimestamp[to] < block.number - 2, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount, "Sell transfer amount exceeds the max sell.");
}
else if (!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty.
if(earlyBuyPenaltyInEffect() && automatedMarketMakerPairs[from] && !automatedMarketMakerPairs[to] && buyTotalFees > 0){
if(!boughtEarly[to]){
boughtEarly[to] = true;
botsCaught += 1;
emit CaughtEarlyBuyer(to);
}
fees = amount * 99 / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForBurn += fees * buyBurnFee / buyTotalFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForOperations += fees * sellOperationsFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForBurn += fees * sellBurnFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForBurn += fees * buyBurnFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| _isExcludedFromFees[from]||_isExcludedFromFees[to],"Trading is not active." | 61,006 | _isExcludedFromFees[from]||_isExcludedFromFees[to] |
"Bots cannot transfer tokens in or out except to owner or dead address." | // SPDX-License-Identifier: MIT
/**
Twitter: https://twitter.com/floshibdotama
Website: https://www.floshibdotama.com/
Tg: https://t.me/FloShibDoTama
*/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FloShibDoTama is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("FloShibDoTama", "4DOG") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if(blockForPenaltyEnd > 0){
require(<FILL_ME>)
}
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number - 2 && _holderLastTransferTimestamp[to] < block.number - 2, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount, "Sell transfer amount exceeds the max sell.");
}
else if (!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty.
if(earlyBuyPenaltyInEffect() && automatedMarketMakerPairs[from] && !automatedMarketMakerPairs[to] && buyTotalFees > 0){
if(!boughtEarly[to]){
boughtEarly[to] = true;
botsCaught += 1;
emit CaughtEarlyBuyer(to);
}
fees = amount * 99 / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForBurn += fees * buyBurnFee / buyTotalFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForOperations += fees * sellOperationsFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForBurn += fees * sellBurnFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForBurn += fees * buyBurnFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| !boughtEarly[from]||to==owner()||to==address(0xdead),"Bots cannot transfer tokens in or out except to owner or dead address." | 61,006 | !boughtEarly[from]||to==owner()||to==address(0xdead) |
"_transfer:: Transfer Delay enabled. Try again later." | // SPDX-License-Identifier: MIT
/**
Twitter: https://twitter.com/floshibdotama
Website: https://www.floshibdotama.com/
Tg: https://t.me/FloShibDoTama
*/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
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() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FloShibDoTama is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("FloShibDoTama", "4DOG") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if(blockForPenaltyEnd > 0){
require(!boughtEarly[from] || to == owner() || to == address(0xdead), "Bots cannot transfer tokens in or out except to owner or dead address.");
}
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(<FILL_ME>)
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount, "Sell transfer amount exceeds the max sell.");
}
else if (!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty.
if(earlyBuyPenaltyInEffect() && automatedMarketMakerPairs[from] && !automatedMarketMakerPairs[to] && buyTotalFees > 0){
if(!boughtEarly[to]){
boughtEarly[to] = true;
botsCaught += 1;
emit CaughtEarlyBuyer(to);
}
fees = amount * 99 / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForBurn += fees * buyBurnFee / buyTotalFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForOperations += fees * sellOperationsFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForBurn += fees * sellBurnFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForBurn += fees * buyBurnFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| _holderLastTransferTimestamp[tx.origin]<block.number-2&&_holderLastTransferTimestamp[to]<block.number-2,"_transfer:: Transfer Delay enabled. Try again later." | 61,006 | _holderLastTransferTimestamp[tx.origin]<block.number-2&&_holderLastTransferTimestamp[to]<block.number-2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.