comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"free mint not enough" | pragma solidity ^0.8.4;
contract ImTired is ERC721A, Ownable {
using Strings for uint256;
string private baseURI;
string public baseExtension = ".json";
uint256 public maxSupply = 5555;
uint256 public maxMintOneTime = 3;
struct SaleConfig {
uint32 freeMintCount;
uint64 publicSalePriceWei;
uint256 saleStartingTime;
}
SaleConfig public saleConfig = SaleConfig(
2000,
0.005 ether,
1654362000
);
constructor(
string memory _initBaseURI
) ERC721A("ImTired","IMTD") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(address _to, uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(block.timestamp > saleConfig.saleStartingTime,"sales not start.");
require(_mintAmount > 0,"mint amount greater than zero.");
require(_mintAmount <= maxMintOneTime,"can not mint this many one time");
uint256 freeMintCount = saleConfig.freeMintCount;
if(supply < freeMintCount){
require(<FILL_ME>)
_safeMint(_to,_mintAmount);
}else{
uint256 publicSalePriceWei = saleConfig.publicSalePriceWei;
require(supply + _mintAmount <= maxSupply,"reached max supply");
require(msg.value >= _mintAmount * publicSalePriceWei,"not enough money");
_safeMint(_to,_mintAmount);
}
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function setStartingTime(uint256 _saleStartingTime) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| _mintAmount+supply<=saleConfig.freeMintCount,"free mint not enough" | 441,231 | _mintAmount+supply<=saleConfig.freeMintCount |
"NethermorphsSummoning: Max regular supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/INethermorphs.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract NethermorphsSummoning is Ownable, Pausable {
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint public maxRegularSupply;
uint public maxRareSupply;
INethermorphs public nethermorphsContract;
IERC721 public totemsContract;
mapping(bytes32 => bool) private _merkleRoots;
constructor(
address nethermorphsContractAddress,
address totemsContractAddress,
uint _maxRegularSupply,
uint _maxRareSupply
) {
}
function mint(
uint regularQty,
uint rareQty,
uint[][] calldata totemsToBurnForRegulars,
uint[][] calldata totemsToBurnForRares,
bytes32 merkleRoot,
bytes32[] calldata merkleProof
) external whenNotPaused {
require(regularQty == totemsToBurnForRegulars.length, "NethermorphsSummoning: Invalid regularQty");
require(rareQty == totemsToBurnForRares.length, "NethermorphsSummoning: Invalid rareQty");
require(<FILL_ME>)
require(nethermorphsContract.raresMinted() + rareQty <= maxRareSupply, "NethermorphsSummoning: Max rare supply exceeded");
require(_merkleRoots[merkleRoot], "NethermorphsSummoning: Invalid merkle root");
require(merkleProof.length > 0, "NethermorphsSummoning: Invalid merkle proof");
bytes32 leaf = _createLeaf(msg.sender, regularQty, rareQty, totemsToBurnForRegulars, totemsToBurnForRares);
require(MerkleProof.verify(merkleProof, merkleRoot, leaf), "NethermorphsSummoning: Unable to verify merkle proof");
if (regularQty > 0) {
for (uint i = 0; i < regularQty; i++) {
for (uint j = 0; j < totemsToBurnForRegulars[i].length; j++) {
totemsContract.transferFrom(msg.sender, BURN_ADDRESS, totemsToBurnForRegulars[i][j]);
}
}
}
if (rareQty > 0) {
for (uint i = 0; i < rareQty; i++) {
for (uint j = 0; j < totemsToBurnForRares[i].length; j++) {
totemsContract.transferFrom(msg.sender, BURN_ADDRESS, totemsToBurnForRares[i][j]);
}
}
}
nethermorphsContract.mint(msg.sender, regularQty, rareQty);
}
function setNethermorphsContract(address _nethermorphsContract) public onlyOwner {
}
function setTotemsContract(address _totemsContract) public onlyOwner {
}
function setMaxRegularSupply(uint _maxRegularSupply) public onlyOwner {
}
function setMaxRareSupply(uint _maxRareSupply) public onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot, bool value) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function _createLeaf(
address sender,
uint regularsQty,
uint raresQty,
uint[][] calldata totemsToBurnForRegulars,
uint[][] calldata totemsToBurnForRares
) private pure returns (bytes32) {
}
}
| nethermorphsContract.regularsMinted()+regularQty<=maxRegularSupply,"NethermorphsSummoning: Max regular supply exceeded" | 441,584 | nethermorphsContract.regularsMinted()+regularQty<=maxRegularSupply |
"NethermorphsSummoning: Max rare supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/INethermorphs.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract NethermorphsSummoning is Ownable, Pausable {
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint public maxRegularSupply;
uint public maxRareSupply;
INethermorphs public nethermorphsContract;
IERC721 public totemsContract;
mapping(bytes32 => bool) private _merkleRoots;
constructor(
address nethermorphsContractAddress,
address totemsContractAddress,
uint _maxRegularSupply,
uint _maxRareSupply
) {
}
function mint(
uint regularQty,
uint rareQty,
uint[][] calldata totemsToBurnForRegulars,
uint[][] calldata totemsToBurnForRares,
bytes32 merkleRoot,
bytes32[] calldata merkleProof
) external whenNotPaused {
require(regularQty == totemsToBurnForRegulars.length, "NethermorphsSummoning: Invalid regularQty");
require(rareQty == totemsToBurnForRares.length, "NethermorphsSummoning: Invalid rareQty");
require(nethermorphsContract.regularsMinted() + regularQty <= maxRegularSupply, "NethermorphsSummoning: Max regular supply exceeded");
require(<FILL_ME>)
require(_merkleRoots[merkleRoot], "NethermorphsSummoning: Invalid merkle root");
require(merkleProof.length > 0, "NethermorphsSummoning: Invalid merkle proof");
bytes32 leaf = _createLeaf(msg.sender, regularQty, rareQty, totemsToBurnForRegulars, totemsToBurnForRares);
require(MerkleProof.verify(merkleProof, merkleRoot, leaf), "NethermorphsSummoning: Unable to verify merkle proof");
if (regularQty > 0) {
for (uint i = 0; i < regularQty; i++) {
for (uint j = 0; j < totemsToBurnForRegulars[i].length; j++) {
totemsContract.transferFrom(msg.sender, BURN_ADDRESS, totemsToBurnForRegulars[i][j]);
}
}
}
if (rareQty > 0) {
for (uint i = 0; i < rareQty; i++) {
for (uint j = 0; j < totemsToBurnForRares[i].length; j++) {
totemsContract.transferFrom(msg.sender, BURN_ADDRESS, totemsToBurnForRares[i][j]);
}
}
}
nethermorphsContract.mint(msg.sender, regularQty, rareQty);
}
function setNethermorphsContract(address _nethermorphsContract) public onlyOwner {
}
function setTotemsContract(address _totemsContract) public onlyOwner {
}
function setMaxRegularSupply(uint _maxRegularSupply) public onlyOwner {
}
function setMaxRareSupply(uint _maxRareSupply) public onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot, bool value) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function _createLeaf(
address sender,
uint regularsQty,
uint raresQty,
uint[][] calldata totemsToBurnForRegulars,
uint[][] calldata totemsToBurnForRares
) private pure returns (bytes32) {
}
}
| nethermorphsContract.raresMinted()+rareQty<=maxRareSupply,"NethermorphsSummoning: Max rare supply exceeded" | 441,584 | nethermorphsContract.raresMinted()+rareQty<=maxRareSupply |
"NethermorphsSummoning: Invalid merkle root" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./interfaces/INethermorphs.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract NethermorphsSummoning is Ownable, Pausable {
address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint public maxRegularSupply;
uint public maxRareSupply;
INethermorphs public nethermorphsContract;
IERC721 public totemsContract;
mapping(bytes32 => bool) private _merkleRoots;
constructor(
address nethermorphsContractAddress,
address totemsContractAddress,
uint _maxRegularSupply,
uint _maxRareSupply
) {
}
function mint(
uint regularQty,
uint rareQty,
uint[][] calldata totemsToBurnForRegulars,
uint[][] calldata totemsToBurnForRares,
bytes32 merkleRoot,
bytes32[] calldata merkleProof
) external whenNotPaused {
require(regularQty == totemsToBurnForRegulars.length, "NethermorphsSummoning: Invalid regularQty");
require(rareQty == totemsToBurnForRares.length, "NethermorphsSummoning: Invalid rareQty");
require(nethermorphsContract.regularsMinted() + regularQty <= maxRegularSupply, "NethermorphsSummoning: Max regular supply exceeded");
require(nethermorphsContract.raresMinted() + rareQty <= maxRareSupply, "NethermorphsSummoning: Max rare supply exceeded");
require(<FILL_ME>)
require(merkleProof.length > 0, "NethermorphsSummoning: Invalid merkle proof");
bytes32 leaf = _createLeaf(msg.sender, regularQty, rareQty, totemsToBurnForRegulars, totemsToBurnForRares);
require(MerkleProof.verify(merkleProof, merkleRoot, leaf), "NethermorphsSummoning: Unable to verify merkle proof");
if (regularQty > 0) {
for (uint i = 0; i < regularQty; i++) {
for (uint j = 0; j < totemsToBurnForRegulars[i].length; j++) {
totemsContract.transferFrom(msg.sender, BURN_ADDRESS, totemsToBurnForRegulars[i][j]);
}
}
}
if (rareQty > 0) {
for (uint i = 0; i < rareQty; i++) {
for (uint j = 0; j < totemsToBurnForRares[i].length; j++) {
totemsContract.transferFrom(msg.sender, BURN_ADDRESS, totemsToBurnForRares[i][j]);
}
}
}
nethermorphsContract.mint(msg.sender, regularQty, rareQty);
}
function setNethermorphsContract(address _nethermorphsContract) public onlyOwner {
}
function setTotemsContract(address _totemsContract) public onlyOwner {
}
function setMaxRegularSupply(uint _maxRegularSupply) public onlyOwner {
}
function setMaxRareSupply(uint _maxRareSupply) public onlyOwner {
}
function setMerkleRoot(bytes32 merkleRoot, bool value) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function _createLeaf(
address sender,
uint regularsQty,
uint raresQty,
uint[][] calldata totemsToBurnForRegulars,
uint[][] calldata totemsToBurnForRares
) private pure returns (bytes32) {
}
}
| _merkleRoots[merkleRoot],"NethermorphsSummoning: Invalid merkle root" | 441,584 | _merkleRoots[merkleRoot] |
"Swap amount cannot be lower than 0.001% total supply." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
contract PEPEINU is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
address public marketingWallet;
bool private swapping;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
// 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 ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("PEPE INU", "PEPEI") {
}
receive() external payable {}
function updateMarketingWallet(address mw) external onlyOwner {
}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
require(<FILL_ME>)
require(
newAmount <= (totalSupply() * 5) / 1000 / 1e18,
"Swap amount cannot be higher than 0.5% total supply."
);
swapTokensAtAmount = newAmount * (10**18);
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
}
| newAmount>=(totalSupply()*1)/100000/1e18,"Swap amount cannot be lower than 0.001% total supply." | 441,618 | newAmount>=(totalSupply()*1)/100000/1e18 |
"Swap amount cannot be higher than 0.5% total supply." | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.1;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
contract PEPEINU is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
address public constant deadAddress = address(0xdead);
address public marketingWallet;
bool private swapping;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
// 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 ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("PEPE INU", "PEPEI") {
}
receive() external payable {}
function updateMarketingWallet(address mw) external onlyOwner {
}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
require(
newAmount >= (totalSupply() * 1) / 100000 / 1e18,
"Swap amount cannot be lower than 0.001% total supply."
);
require(<FILL_ME>)
swapTokensAtAmount = newAmount * (10**18);
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee
) external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
}
| newAmount<=(totalSupply()*5)/1000/1e18,"Swap amount cannot be higher than 0.5% total supply." | 441,618 | newAmount<=(totalSupply()*5)/1000/1e18 |
"Blacklisted" | // 🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑
// #PUMPTOBER the month where all your degen wishes come true.
// Just imagine....market getting green, memecoins are pumping, and #PUMPTOBER is leading the way!
// It is that time of the year again, when all hope in the simple degen life gets restored!
// Are you ready for the pump?
// Every 2 hours over 7 days, 20% supply reductions happen, totaling 84 enchanting transformations! 🚀
// During each rebase, your token count decreases by 20%, while the value increases by the same %. 🚀💰
// Website: https://pumptober.vip
// Telegram: https://t.me/PumptoberToken
// X/Twitter: https://twitter.com/Pumptober23
// 🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface InterfaceLP {
function sync() external;
function mint(address to) external returns (uint liquidity);
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint8 _tokenDecimals
) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
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;
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Ownable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
}
}
interface IWETH {
function deposit() external payable;
}
contract PUMPTOBER is ERC20Detailed, Ownable {
uint256 public rebaseFrequency = 2 hours;
uint256 public nextRebase;
uint256 public finalRebase;
bool public autoRebase = true;
bool public rebaseStarted = false;
uint256 public rebasesThisCycle;
uint256 public lastRebaseThisCycle;
uint256 public maxTxnAmount;
uint256 public maxWallet;
address public taxWallet;
uint256 public taxPercentBuy;
uint256 public taxPercentSell;
string public _1_x;
string public _2_telegram;
string public _3_website;
mapping (address => bool) public isWhitelisted;
uint8 private constant DECIMALS = 9;
uint256 private constant INITIAL_TOKENS_SUPPLY = 18_236_939_125_700_000 * 10**DECIMALS;
uint256 private constant TOTAL_PARTS = type(uint256).max - (type(uint256).max % INITIAL_TOKENS_SUPPLY);
event Rebase(uint256 indexed time, uint256 totalSupply);
event RemovedLimits();
IWETH public immutable weth;
IDEXRouter public immutable router;
address public immutable pair;
bool public limitsInEffect = true;
bool public tradingIsLive = false;
uint256 private _totalSupply;
uint256 private _partsPerToken;
uint256 private partsSwapThreshold = (TOTAL_PARTS / 100000 * 25);
mapping(address => uint256) private _partBalances;
mapping(address => mapping(address => uint256)) private _allowedTokens;
mapping(address => bool) private _bots;
modifier validRecipient(address to) {
}
bool inSwap;
modifier swapping() {
}
constructor() ERC20Detailed(block.chainid==1 ? "Pumptober" : "ETEST", block.chainid==1 ? "PUMPTOBER" : "ETEST", DECIMALS) {
}
function totalSupply() external view override returns (uint256) {
}
function allowance(address owner_, address spender) external view override returns (uint256){
}
function balanceOf(address who) public view override returns (uint256) {
}
function shouldRebase() public view returns (bool) {
}
function lpSync() internal {
}
function transfer(address to, uint256 value) external override validRecipient(to) returns (bool){
}
function removeLimits() external onlyOwner {
}
function whitelistWallet(address _address, bool _isWhitelisted) external onlyOwner {
}
function updateMarketingWallet(address _address) external onlyOwner {
}
function updateTaxPercent(uint256 _taxPercentBuy, uint256 _taxPercentSell) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
address pairAddress = pair;
uint256 partAmount = amount*(_partsPerToken);
require(<FILL_ME>)
if(autoRebase && !inSwap && !isWhitelisted[sender] && !isWhitelisted[recipient]){
require(tradingIsLive, "Trading not live");
if(limitsInEffect){
if (sender == pairAddress || recipient == pairAddress){
require(amount <= maxTxnAmount, "Max Tx Exceeded");
}
if (recipient != pairAddress){
require(balanceOf(recipient) + amount <= maxWallet, "Max Wallet Exceeded");
}
}
if(recipient == pairAddress){
if(balanceOf(address(this)) >= partsSwapThreshold/(_partsPerToken)){
try this.swapBack(){} catch {}
}
if(shouldRebase()){
rebase();
}
}
uint256 taxPartAmount;
if(sender == pairAddress){
taxPartAmount = partAmount * taxPercentBuy / 100;
}
else if (recipient == pairAddress) {
taxPartAmount = partAmount * taxPercentSell / 100;
}
if(taxPartAmount > 0){
_partBalances[sender] -= taxPartAmount;
_partBalances[address(this)] += taxPartAmount;
emit Transfer(sender, address(this), taxPartAmount / _partsPerToken);
partAmount -= taxPartAmount;
}
}
_partBalances[sender] = _partBalances[sender]-(partAmount);
_partBalances[recipient] = _partBalances[recipient]+(partAmount);
emit Transfer(sender, recipient, partAmount/(_partsPerToken));
return true;
}
function transferFrom(address from, address to, uint256 value) external override validRecipient(to) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool){
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool){
}
function approve(address spender, uint256 value) public override returns (bool){
}
function rebase() internal returns (uint256) {
}
function manualRebase() external {
}
function enableTrading() external onlyOwner {
}
function startRebaseCycles() external onlyOwner {
}
function manageBots(address[] memory _accounts, bool _isBot) external onlyOwner {
}
function swapBack() public swapping {
}
function swapTokensForETH(uint256 tokenAmount) internal {
}
function refreshBalances(address[] memory wallets) external {
}
receive() external payable {}
}
| !_bots[sender]&&!_bots[recipient]&&!_bots[msg.sender],"Blacklisted" | 441,882 | !_bots[sender]&&!_bots[recipient]&&!_bots[msg.sender] |
"Not in time" | // 🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑
// #PUMPTOBER the month where all your degen wishes come true.
// Just imagine....market getting green, memecoins are pumping, and #PUMPTOBER is leading the way!
// It is that time of the year again, when all hope in the simple degen life gets restored!
// Are you ready for the pump?
// Every 2 hours over 7 days, 20% supply reductions happen, totaling 84 enchanting transformations! 🚀
// During each rebase, your token count decreases by 20%, while the value increases by the same %. 🚀💰
// Website: https://pumptober.vip
// Telegram: https://t.me/PumptoberToken
// X/Twitter: https://twitter.com/Pumptober23
// 🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface InterfaceLP {
function sync() external;
function mint(address to) external returns (uint liquidity);
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint8 _tokenDecimals
) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
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;
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Ownable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
}
}
interface IWETH {
function deposit() external payable;
}
contract PUMPTOBER is ERC20Detailed, Ownable {
uint256 public rebaseFrequency = 2 hours;
uint256 public nextRebase;
uint256 public finalRebase;
bool public autoRebase = true;
bool public rebaseStarted = false;
uint256 public rebasesThisCycle;
uint256 public lastRebaseThisCycle;
uint256 public maxTxnAmount;
uint256 public maxWallet;
address public taxWallet;
uint256 public taxPercentBuy;
uint256 public taxPercentSell;
string public _1_x;
string public _2_telegram;
string public _3_website;
mapping (address => bool) public isWhitelisted;
uint8 private constant DECIMALS = 9;
uint256 private constant INITIAL_TOKENS_SUPPLY = 18_236_939_125_700_000 * 10**DECIMALS;
uint256 private constant TOTAL_PARTS = type(uint256).max - (type(uint256).max % INITIAL_TOKENS_SUPPLY);
event Rebase(uint256 indexed time, uint256 totalSupply);
event RemovedLimits();
IWETH public immutable weth;
IDEXRouter public immutable router;
address public immutable pair;
bool public limitsInEffect = true;
bool public tradingIsLive = false;
uint256 private _totalSupply;
uint256 private _partsPerToken;
uint256 private partsSwapThreshold = (TOTAL_PARTS / 100000 * 25);
mapping(address => uint256) private _partBalances;
mapping(address => mapping(address => uint256)) private _allowedTokens;
mapping(address => bool) private _bots;
modifier validRecipient(address to) {
}
bool inSwap;
modifier swapping() {
}
constructor() ERC20Detailed(block.chainid==1 ? "Pumptober" : "ETEST", block.chainid==1 ? "PUMPTOBER" : "ETEST", DECIMALS) {
}
function totalSupply() external view override returns (uint256) {
}
function allowance(address owner_, address spender) external view override returns (uint256){
}
function balanceOf(address who) public view override returns (uint256) {
}
function shouldRebase() public view returns (bool) {
}
function lpSync() internal {
}
function transfer(address to, uint256 value) external override validRecipient(to) returns (bool){
}
function removeLimits() external onlyOwner {
}
function whitelistWallet(address _address, bool _isWhitelisted) external onlyOwner {
}
function updateMarketingWallet(address _address) external onlyOwner {
}
function updateTaxPercent(uint256 _taxPercentBuy, uint256 _taxPercentSell) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transferFrom(address from, address to, uint256 value) external override validRecipient(to) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool){
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool){
}
function approve(address spender, uint256 value) public override returns (bool){
}
function rebase() internal returns (uint256) {
}
function manualRebase() external {
require(<FILL_ME>)
rebase();
}
function enableTrading() external onlyOwner {
}
function startRebaseCycles() external onlyOwner {
}
function manageBots(address[] memory _accounts, bool _isBot) external onlyOwner {
}
function swapBack() public swapping {
}
function swapTokensForETH(uint256 tokenAmount) internal {
}
function refreshBalances(address[] memory wallets) external {
}
receive() external payable {}
}
| shouldRebase(),"Not in time" | 441,882 | shouldRebase() |
"already started" | // 🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑
// #PUMPTOBER the month where all your degen wishes come true.
// Just imagine....market getting green, memecoins are pumping, and #PUMPTOBER is leading the way!
// It is that time of the year again, when all hope in the simple degen life gets restored!
// Are you ready for the pump?
// Every 2 hours over 7 days, 20% supply reductions happen, totaling 84 enchanting transformations! 🚀
// During each rebase, your token count decreases by 20%, while the value increases by the same %. 🚀💰
// Website: https://pumptober.vip
// Telegram: https://t.me/PumptoberToken
// X/Twitter: https://twitter.com/Pumptober23
// 🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑🤑
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface InterfaceLP {
function sync() external;
function mint(address to) external returns (uint liquidity);
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint8 _tokenDecimals
) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
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;
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Ownable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
}
}
interface IWETH {
function deposit() external payable;
}
contract PUMPTOBER is ERC20Detailed, Ownable {
uint256 public rebaseFrequency = 2 hours;
uint256 public nextRebase;
uint256 public finalRebase;
bool public autoRebase = true;
bool public rebaseStarted = false;
uint256 public rebasesThisCycle;
uint256 public lastRebaseThisCycle;
uint256 public maxTxnAmount;
uint256 public maxWallet;
address public taxWallet;
uint256 public taxPercentBuy;
uint256 public taxPercentSell;
string public _1_x;
string public _2_telegram;
string public _3_website;
mapping (address => bool) public isWhitelisted;
uint8 private constant DECIMALS = 9;
uint256 private constant INITIAL_TOKENS_SUPPLY = 18_236_939_125_700_000 * 10**DECIMALS;
uint256 private constant TOTAL_PARTS = type(uint256).max - (type(uint256).max % INITIAL_TOKENS_SUPPLY);
event Rebase(uint256 indexed time, uint256 totalSupply);
event RemovedLimits();
IWETH public immutable weth;
IDEXRouter public immutable router;
address public immutable pair;
bool public limitsInEffect = true;
bool public tradingIsLive = false;
uint256 private _totalSupply;
uint256 private _partsPerToken;
uint256 private partsSwapThreshold = (TOTAL_PARTS / 100000 * 25);
mapping(address => uint256) private _partBalances;
mapping(address => mapping(address => uint256)) private _allowedTokens;
mapping(address => bool) private _bots;
modifier validRecipient(address to) {
}
bool inSwap;
modifier swapping() {
}
constructor() ERC20Detailed(block.chainid==1 ? "Pumptober" : "ETEST", block.chainid==1 ? "PUMPTOBER" : "ETEST", DECIMALS) {
}
function totalSupply() external view override returns (uint256) {
}
function allowance(address owner_, address spender) external view override returns (uint256){
}
function balanceOf(address who) public view override returns (uint256) {
}
function shouldRebase() public view returns (bool) {
}
function lpSync() internal {
}
function transfer(address to, uint256 value) external override validRecipient(to) returns (bool){
}
function removeLimits() external onlyOwner {
}
function whitelistWallet(address _address, bool _isWhitelisted) external onlyOwner {
}
function updateMarketingWallet(address _address) external onlyOwner {
}
function updateTaxPercent(uint256 _taxPercentBuy, uint256 _taxPercentSell) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transferFrom(address from, address to, uint256 value) external override validRecipient(to) returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool){
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool){
}
function approve(address spender, uint256 value) public override returns (bool){
}
function rebase() internal returns (uint256) {
}
function manualRebase() external {
}
function enableTrading() external onlyOwner {
}
function startRebaseCycles() external onlyOwner {
require(<FILL_ME>)
nextRebase = block.timestamp + rebaseFrequency;
finalRebase = block.timestamp + 7 days;
rebaseStarted = true;
}
function manageBots(address[] memory _accounts, bool _isBot) external onlyOwner {
}
function swapBack() public swapping {
}
function swapTokensForETH(uint256 tokenAmount) internal {
}
function refreshBalances(address[] memory wallets) external {
}
receive() external payable {}
}
| !rebaseStarted,"already started" | 441,882 | !rebaseStarted |
"Request not found." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./interfaces/IMaster.sol";
import "./interfaces/IMetaDataOracle.sol";
contract MetaDataOracle is AccessControl, IMetaDataOracle {
/// @notice struct for response
struct Response {
address providerAddress;
address callerAddress;
string json;
}
bytes32 public constant PROVIDER_ROLE = keccak256("PROVIDER_ROLE");
event MetadataRequested(address sender, uint id, uint tokenId);
event MetaDataReturned(string json, address caller, uint id);
event ProviderAdded(address provider);
event ProviderRemoved(address provider);
event ProvidersThresholdChanged(uint n);
/// @notice how many contracts may refer to it
uint private numProviders = 0;
uint private providersThreshold = 1;
uint private randNonce = 0;
mapping(uint256 => bool) private pendingRequests;
mapping(uint256 => Response[]) private idToResponses;
event Received(address, uint);
constructor() {
}
receive() external payable {
}
function takeRole(address caller) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice Funcrtion that create request for metadata
/// @param tokenId the token we are interested in
/// @return id - ID of request
function requestMetaData(uint tokenId) external override returns (uint256) {
}
function returnMetadata(string memory json, address callerAddress, uint256 id, uint tokenId) external override onlyRole(PROVIDER_ROLE) {
require(<FILL_ME>)
Response memory res = Response(msg.sender, callerAddress, json);
idToResponses[id].push(res);
uint numResponses = idToResponses[id].length;
if (numResponses == providersThreshold) {
string memory resJSON = "";
for (uint i=0; i < idToResponses[id].length; i++) {
resJSON = idToResponses[id][i].json;
}
delete pendingRequests[id];
delete idToResponses[id];
IMaster(callerAddress).fulfillMetaDataRequest(resJSON, id, tokenId);
emit MetaDataReturned(resJSON, callerAddress, id);
}
}
function addProvider(address provider) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
function removeProvider(address provider) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setProvidersThreshold(uint threshold) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| pendingRequests[id],"Request not found." | 441,892 | pendingRequests[id] |
"Provider already added." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "./interfaces/IMaster.sol";
import "./interfaces/IMetaDataOracle.sol";
contract MetaDataOracle is AccessControl, IMetaDataOracle {
/// @notice struct for response
struct Response {
address providerAddress;
address callerAddress;
string json;
}
bytes32 public constant PROVIDER_ROLE = keccak256("PROVIDER_ROLE");
event MetadataRequested(address sender, uint id, uint tokenId);
event MetaDataReturned(string json, address caller, uint id);
event ProviderAdded(address provider);
event ProviderRemoved(address provider);
event ProvidersThresholdChanged(uint n);
/// @notice how many contracts may refer to it
uint private numProviders = 0;
uint private providersThreshold = 1;
uint private randNonce = 0;
mapping(uint256 => bool) private pendingRequests;
mapping(uint256 => Response[]) private idToResponses;
event Received(address, uint);
constructor() {
}
receive() external payable {
}
function takeRole(address caller) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
/// @notice Funcrtion that create request for metadata
/// @param tokenId the token we are interested in
/// @return id - ID of request
function requestMetaData(uint tokenId) external override returns (uint256) {
}
function returnMetadata(string memory json, address callerAddress, uint256 id, uint tokenId) external override onlyRole(PROVIDER_ROLE) {
}
function addProvider(address provider) external override onlyRole(DEFAULT_ADMIN_ROLE) {
require(<FILL_ME>)
_grantRole(PROVIDER_ROLE, provider);
numProviders++;
emit ProviderAdded(provider);
}
function removeProvider(address provider) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setProvidersThreshold(uint threshold) external override onlyRole(DEFAULT_ADMIN_ROLE) {
}
}
| !hasRole(PROVIDER_ROLE,provider),"Provider already added." | 441,892 | !hasRole(PROVIDER_ROLE,provider) |
"Goat: invalid signature" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.6;
import "./Goat.sol";
contract GoatV2 is Goat {
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
address _signer
) Goat(_name, _symbol, _initBaseURI, _signer) {}
function sendToken(
uint256 _tokenId,
address _receiver,
uint256 _price,
bytes memory _signature
) external payable override {
address owner = ownerOf(_tokenId);
require(<FILL_ME>)
require(msg.value >= _price, "Goat: price is higher than the amount of ETH sent");
safeTransferFromWithoutCheckingNesting(owner, _receiver, _tokenId);
if (_price != 0) {
(bool success, ) = address(owner).call{value: _price}("");
require(success, "Unable to send ETH to owner of token");
if (_price < msg.value) {
(success, ) = address(_receiver).call{value: msg.value - _price}("");
require(success, "Unable to send ETH to buyer");
}
}
sendNonce[_tokenId] += 1;
}
}
| isSignatureValid(owner,_receiver,_tokenId,_price,sendNonce[_tokenId],_signature),"Goat: invalid signature" | 442,343 | isSignatureValid(owner,_receiver,_tokenId,_price,sendNonce[_tokenId],_signature) |
"Only Owner/Minter allowed" | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "erc721a/contracts/ERC721A.sol";
contract ItemERC721A is ERC721A, Ownable, AccessControl {
using Strings for uint256;
string private baseURI;
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
uint256 public activeEdition;
// ============ MODIFIERS ============
modifier onlyOwnerOrManager() {
require(<FILL_ME>)
_;
}
modifier onlyActiveEdition(uint256 _edition){
}
// ========== CONSTRUCTOR =================
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address _minter
) ERC721A(_name, _symbol) {
}
function setBaseURI(string memory _uri) external onlyOwnerOrManager {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function safeMintMany(address recipient, uint256 amount, uint256 _activeEdition)
external
onlyOwnerOrManager
onlyActiveEdition(_activeEdition) {
}
function airdrop(address[] calldata addresses, uint256 _activeEdition)
external
onlyOwnerOrManager
onlyActiveEdition(_activeEdition)
{
}
function setActiveEdition(uint256 _activeEdition) public onlyOwnerOrManager {
}
// ============ FUNCTION OVERRIDES ============
/**
* To change the starting tokenId, please override this function.
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, AccessControl)
returns (bool)
{
}
}
| hasRole(MINTER_ROLE,_msgSender())||owner()==_msgSender(),"Only Owner/Minter allowed" | 442,546 | hasRole(MINTER_ROLE,_msgSender())||owner()==_msgSender() |
"SafeModule: role deprecated" | // SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./GnosisSafe.sol";
import "./Enums.sol";
import "./Permissions.sol";
contract SafeModule is Ownable {
string public constant version = "0.2.0";
uint256 internal constant _MAX_ROLE_PER_MEMBER = 16;
event ModuleSetup(address owner, address safeProxy);
event AssignRoles(address member, bytes32[_MAX_ROLE_PER_MEMBER] roleNames);
event DeprecateRole(bytes32 roleName);
event ExecTransaction(
address to,
uint256 value,
bytes data,
Operation operation,
address sender
);
mapping(bytes32 => Role) internal roles;
mapping(address => bytes32[_MAX_ROLE_PER_MEMBER]) internal members;
mapping(bytes32 => bool) internal deprecatedRoles;
address public _safeProxy;
constructor(address owner, address payable safeProxy) {
}
function setUp(bytes memory initParams) public {
}
modifier isValidRoleName(bytes32 roleName) {
require(roleName != 0, "SafeModule: empty role name");
require(<FILL_ME>)
_;
}
/// @dev Assign roles to a member
/// @param member address
/// @param roleNames Id of a roles
/// @notice Can only be called by owner
function assignRoles(address member, bytes32[] memory roleNames)
external
onlyOwner
{
}
/// @dev Deprecate a roleName and this roleName can't used anymore
/// @param roleName Id of a role
/// @notice Can only be called by owner
function deprecateRole(bytes32 roleName)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Get roles of an address for now
/// @param member Member address
function rolesOf(address member)
public
view
returns (bytes32[] memory validRoles)
{
}
function hasRole(address member, bytes32 roleName)
public
view
returns (bool)
{
}
/// @dev Allow the specific roleName to call the contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
function allowContract(
bytes32 roleName,
address theContract,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Disable the specific roleName to call the contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @notice Can only be called by owner
function revokeContract(bytes32 roleName, address theContract)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Allow the specific roleName to call the function of contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @notice Can only be called by owner
function scopeContract(bytes32 roleName, address theContract)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Allow the specific roleName to call the function
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
/// @notice Please call 'scopeContract' at the begin before config function
function allowFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Disable the specific roleName to call the function
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @notice Can only be called by owner
function revokeFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Allow the specific roleName to call the function with specific parameters
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @param isScopeds List of parameter scoped config, false for un-scoped, true for scoped
/// @param parameterTypes List of parameter types, Static, Dynamic or Dynamic32, use Static type if not scoped
/// @param comparisons List of parameter comparison types, Eq, Gte or Lte, use Eq if not scoped
/// @param targetValues List of expected values, use '0x' if not scoped
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
/// @notice Please call 'scopeContract' at the begin before config function
function scopeFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig,
uint256 ethValueLimit,
bool[] memory isScopeds,
ParameterType[] memory parameterTypes,
Comparison[] memory comparisons,
bytes[] calldata targetValues,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Check then exec transaction
/// @param roleName role to execute this call
/// @param to To address of the transaction
/// @param value Ether value of the transaction
/// @param data Data payload of the transaction
/// @param operation Operation to execute the transaction, only call or delegateCall
function execTransactionFromModule(
bytes32 roleName,
address to,
uint256 value,
bytes calldata data,
Operation operation
) public {
}
struct Exec {
bytes32 roleName;
address to;
uint256 value;
bytes data;
Operation operation;
}
function execTransactionsFromModule(Exec[] calldata execs) public {
}
function _execTransaction(
bytes32 roleName,
address to,
uint256 value,
bytes memory data,
Operation operation
) internal isValidRoleName(roleName) {
}
function _verifyPermission(
bytes32 roleName,
address to,
uint256 value,
bytes memory data,
Operation operation
) internal view {
}
}
| !deprecatedRoles[roleName],"SafeModule: role deprecated" | 442,558 | !deprecatedRoles[roleName] |
"SafeModule: execute fail on gnosis safe" | // SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./GnosisSafe.sol";
import "./Enums.sol";
import "./Permissions.sol";
contract SafeModule is Ownable {
string public constant version = "0.2.0";
uint256 internal constant _MAX_ROLE_PER_MEMBER = 16;
event ModuleSetup(address owner, address safeProxy);
event AssignRoles(address member, bytes32[_MAX_ROLE_PER_MEMBER] roleNames);
event DeprecateRole(bytes32 roleName);
event ExecTransaction(
address to,
uint256 value,
bytes data,
Operation operation,
address sender
);
mapping(bytes32 => Role) internal roles;
mapping(address => bytes32[_MAX_ROLE_PER_MEMBER]) internal members;
mapping(bytes32 => bool) internal deprecatedRoles;
address public _safeProxy;
constructor(address owner, address payable safeProxy) {
}
function setUp(bytes memory initParams) public {
}
modifier isValidRoleName(bytes32 roleName) {
}
/// @dev Assign roles to a member
/// @param member address
/// @param roleNames Id of a roles
/// @notice Can only be called by owner
function assignRoles(address member, bytes32[] memory roleNames)
external
onlyOwner
{
}
/// @dev Deprecate a roleName and this roleName can't used anymore
/// @param roleName Id of a role
/// @notice Can only be called by owner
function deprecateRole(bytes32 roleName)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Get roles of an address for now
/// @param member Member address
function rolesOf(address member)
public
view
returns (bytes32[] memory validRoles)
{
}
function hasRole(address member, bytes32 roleName)
public
view
returns (bool)
{
}
/// @dev Allow the specific roleName to call the contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
function allowContract(
bytes32 roleName,
address theContract,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Disable the specific roleName to call the contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @notice Can only be called by owner
function revokeContract(bytes32 roleName, address theContract)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Allow the specific roleName to call the function of contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @notice Can only be called by owner
function scopeContract(bytes32 roleName, address theContract)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Allow the specific roleName to call the function
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
/// @notice Please call 'scopeContract' at the begin before config function
function allowFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Disable the specific roleName to call the function
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @notice Can only be called by owner
function revokeFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Allow the specific roleName to call the function with specific parameters
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @param isScopeds List of parameter scoped config, false for un-scoped, true for scoped
/// @param parameterTypes List of parameter types, Static, Dynamic or Dynamic32, use Static type if not scoped
/// @param comparisons List of parameter comparison types, Eq, Gte or Lte, use Eq if not scoped
/// @param targetValues List of expected values, use '0x' if not scoped
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
/// @notice Please call 'scopeContract' at the begin before config function
function scopeFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig,
uint256 ethValueLimit,
bool[] memory isScopeds,
ParameterType[] memory parameterTypes,
Comparison[] memory comparisons,
bytes[] calldata targetValues,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Check then exec transaction
/// @param roleName role to execute this call
/// @param to To address of the transaction
/// @param value Ether value of the transaction
/// @param data Data payload of the transaction
/// @param operation Operation to execute the transaction, only call or delegateCall
function execTransactionFromModule(
bytes32 roleName,
address to,
uint256 value,
bytes calldata data,
Operation operation
) public {
}
struct Exec {
bytes32 roleName;
address to;
uint256 value;
bytes data;
Operation operation;
}
function execTransactionsFromModule(Exec[] calldata execs) public {
}
function _execTransaction(
bytes32 roleName,
address to,
uint256 value,
bytes memory data,
Operation operation
) internal isValidRoleName(roleName) {
require(
operation == Operation.Call || operation == Operation.DelegateCall,
"SafeModule: only support call or delegatecall"
);
_verifyPermission(roleName, to, value, data, operation);
require(<FILL_ME>)
emit ExecTransaction(to, value, data, operation, _msgSender());
}
function _verifyPermission(
bytes32 roleName,
address to,
uint256 value,
bytes memory data,
Operation operation
) internal view {
}
}
| GnosisSafe(payable(_safeProxy)).execTransactionFromModule(to,value,data,operation==Operation.DelegateCall?GnosisSafeEnum.Operation.DelegateCall:GnosisSafeEnum.Operation.Call),"SafeModule: execute fail on gnosis safe" | 442,558 | GnosisSafe(payable(_safeProxy)).execTransactionFromModule(to,value,data,operation==Operation.DelegateCall?GnosisSafeEnum.Operation.DelegateCall:GnosisSafeEnum.Operation.Call) |
"SafeModule: sender doesn't have this role" | // SPDX-License-Identifier: LGPL-3.0-only
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./GnosisSafe.sol";
import "./Enums.sol";
import "./Permissions.sol";
contract SafeModule is Ownable {
string public constant version = "0.2.0";
uint256 internal constant _MAX_ROLE_PER_MEMBER = 16;
event ModuleSetup(address owner, address safeProxy);
event AssignRoles(address member, bytes32[_MAX_ROLE_PER_MEMBER] roleNames);
event DeprecateRole(bytes32 roleName);
event ExecTransaction(
address to,
uint256 value,
bytes data,
Operation operation,
address sender
);
mapping(bytes32 => Role) internal roles;
mapping(address => bytes32[_MAX_ROLE_PER_MEMBER]) internal members;
mapping(bytes32 => bool) internal deprecatedRoles;
address public _safeProxy;
constructor(address owner, address payable safeProxy) {
}
function setUp(bytes memory initParams) public {
}
modifier isValidRoleName(bytes32 roleName) {
}
/// @dev Assign roles to a member
/// @param member address
/// @param roleNames Id of a roles
/// @notice Can only be called by owner
function assignRoles(address member, bytes32[] memory roleNames)
external
onlyOwner
{
}
/// @dev Deprecate a roleName and this roleName can't used anymore
/// @param roleName Id of a role
/// @notice Can only be called by owner
function deprecateRole(bytes32 roleName)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Get roles of an address for now
/// @param member Member address
function rolesOf(address member)
public
view
returns (bytes32[] memory validRoles)
{
}
function hasRole(address member, bytes32 roleName)
public
view
returns (bool)
{
}
/// @dev Allow the specific roleName to call the contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
function allowContract(
bytes32 roleName,
address theContract,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Disable the specific roleName to call the contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @notice Can only be called by owner
function revokeContract(bytes32 roleName, address theContract)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Allow the specific roleName to call the function of contract
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @notice Can only be called by owner
function scopeContract(bytes32 roleName, address theContract)
external
onlyOwner
isValidRoleName(roleName)
{
}
/// @dev Allow the specific roleName to call the function
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
/// @notice Please call 'scopeContract' at the begin before config function
function allowFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Disable the specific roleName to call the function
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @notice Can only be called by owner
function revokeFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Allow the specific roleName to call the function with specific parameters
/// @param roleName Id of a role
/// @param theContract Allowed contract
/// @param funcSig Function selector
/// @param isScopeds List of parameter scoped config, false for un-scoped, true for scoped
/// @param parameterTypes List of parameter types, Static, Dynamic or Dynamic32, use Static type if not scoped
/// @param comparisons List of parameter comparison types, Eq, Gte or Lte, use Eq if not scoped
/// @param targetValues List of expected values, use '0x' if not scoped
/// @param operation Defines the operation is call or delegateCall
/// @notice Can only be called by owner
/// @notice Please call 'scopeContract' at the begin before config function
function scopeFunction(
bytes32 roleName,
address theContract,
bytes4 funcSig,
uint256 ethValueLimit,
bool[] memory isScopeds,
ParameterType[] memory parameterTypes,
Comparison[] memory comparisons,
bytes[] calldata targetValues,
Operation operation
) external onlyOwner isValidRoleName(roleName) {
}
/// @dev Check then exec transaction
/// @param roleName role to execute this call
/// @param to To address of the transaction
/// @param value Ether value of the transaction
/// @param data Data payload of the transaction
/// @param operation Operation to execute the transaction, only call or delegateCall
function execTransactionFromModule(
bytes32 roleName,
address to,
uint256 value,
bytes calldata data,
Operation operation
) public {
}
struct Exec {
bytes32 roleName;
address to;
uint256 value;
bytes data;
Operation operation;
}
function execTransactionsFromModule(Exec[] calldata execs) public {
}
function _execTransaction(
bytes32 roleName,
address to,
uint256 value,
bytes memory data,
Operation operation
) internal isValidRoleName(roleName) {
}
function _verifyPermission(
bytes32 roleName,
address to,
uint256 value,
bytes memory data,
Operation operation
) internal view {
require(<FILL_ME>)
Permissions.verify(roles[roleName], to, value, data, operation);
}
}
| hasRole(_msgSender(),roleName),"SafeModule: sender doesn't have this role" | 442,558 | hasRole(_msgSender(),roleName) |
"wrong-receipt-token" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IPoolRewards.sol";
import "../../interfaces/aave/IAave.sol";
import "../Strategy.sol";
import "./AaveCore.sol";
// solhint-disable no-empty-blocks
/// @title Deposit Collateral in Aave and earn interest by depositing borrowed token in a Vesper Pool.
contract AaveXYStrategy is Strategy, AaveCore {
using SafeERC20 for IERC20;
// solhint-disable-next-line var-name-mixedcase
string public NAME;
string public constant VERSION = "5.0.0";
uint256 internal constant MAX_BPS = 10_000; //100%
uint256 public minBorrowLimit = 7_000; // 70% of actual collateral factor of protocol
uint256 public maxBorrowLimit = 8_500; // 85% of actual collateral factor of protocol
uint32 internal constant TWAP_PERIOD = 3600;
address public rewardToken;
address public borrowToken;
AToken public vdToken; // Variable Debt Token
address internal aBorrowToken;
event UpdatedBorrowLimit(
uint256 previousMinBorrowLimit,
uint256 newMinBorrowLimit,
uint256 previousMaxBorrowLimit,
uint256 newMaxBorrowLimit
);
constructor(
address _pool,
address _swapper,
address _rewardToken,
address _receiptToken,
address _borrowToken,
string memory _name
) Strategy(_pool, _swapper, _receiptToken) AaveCore(_receiptToken) {
}
function isReservedToken(address _token) public view virtual override returns (bool) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view override returns (uint256) {
}
/// @notice After borrowing Y Hook
function _afterBorrowY(uint256 _amount) internal virtual {}
/// @notice Approve all required tokens
function _approveToken(uint256 _amount) internal virtual override {
}
/**
* @notice Claim rewardToken and transfer to new strategy
* @param _newStrategy Address of new strategy.
*/
function _beforeMigration(address _newStrategy) internal virtual override {
require(<FILL_ME>)
_repayY(vdToken.balanceOf(address(this)));
}
/// @notice Before repaying Y Hook
function _beforeRepayY(uint256 _amount) internal virtual {}
function _borrowY(uint256 _amount) internal virtual {
}
/**
* @notice Calculate borrow and repay amount based on current collateral and new deposit/withdraw amount.
* @param _depositAmount deposit amount
* @param _withdrawAmount withdraw amount
* @return _borrowAmount borrow more amount
* @return _repayAmount repay amount to keep ltv within limit
*/
function _calculateBorrowPosition(uint256 _depositAmount, uint256 _withdrawAmount)
internal
view
returns (uint256 _borrowAmount, uint256 _repayAmount)
{
}
/// @notice Deposit collateral in Aave and adjust borrow position
function _deposit() internal {
}
/// @notice Borrowed Y balance deposited here or elsewhere hook
function _getInvestedBorrowBalance() internal view virtual returns (uint256) {
}
/**
* @dev Aave support WETH as collateral.
*/
function _mint(uint256 _amount) internal virtual {
}
/**
* @notice Generate report for pools accounting and also send profit and any payback to pool.
* @dev Claim rewardToken and convert to collateral.
*/
function _rebalance()
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _payback
)
{
}
/// @notice Swap excess borrow for more collateral hook
function _rebalanceBorrow(uint256 _excessBorrow) internal virtual {}
function _redeemX(uint256 _amount) internal virtual {
}
function _repayY(uint256 _amount) internal virtual {
}
/**
* @notice Swap given token to borrowToken
* @param _shortOnBorrow Expected output of this swap
*/
function _swapToBorrowToken(uint256 _shortOnBorrow) internal {
}
/// @dev Withdraw collateral here. Do not transfer to pool
function _withdrawHere(uint256 _amount) internal override {
}
/************************************************************************************************
* Governor/admin/keeper function *
***********************************************************************************************/
/**
* @notice Update upper and lower borrow limit. Usually maxBorrowLimit < 100% of actual collateral factor of protocol.
* @dev It is possible to set _maxBorrowLimit and _minBorrowLimit as 0 to not borrow anything
* @param _minBorrowLimit It is % of actual collateral factor of protocol
* @param _maxBorrowLimit It is % of actual collateral factor of protocol
*/
function updateBorrowLimit(uint256 _minBorrowLimit, uint256 _maxBorrowLimit) external onlyGovernor {
}
}
| IStrategy(_newStrategy).token()==address(aToken),"wrong-receipt-token" | 442,607 | IStrategy(_newStrategy).token()==address(aToken) |
"max-should-be-higher-than-min" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import "vesper-pools/contracts/interfaces/vesper/IPoolRewards.sol";
import "../../interfaces/aave/IAave.sol";
import "../Strategy.sol";
import "./AaveCore.sol";
// solhint-disable no-empty-blocks
/// @title Deposit Collateral in Aave and earn interest by depositing borrowed token in a Vesper Pool.
contract AaveXYStrategy is Strategy, AaveCore {
using SafeERC20 for IERC20;
// solhint-disable-next-line var-name-mixedcase
string public NAME;
string public constant VERSION = "5.0.0";
uint256 internal constant MAX_BPS = 10_000; //100%
uint256 public minBorrowLimit = 7_000; // 70% of actual collateral factor of protocol
uint256 public maxBorrowLimit = 8_500; // 85% of actual collateral factor of protocol
uint32 internal constant TWAP_PERIOD = 3600;
address public rewardToken;
address public borrowToken;
AToken public vdToken; // Variable Debt Token
address internal aBorrowToken;
event UpdatedBorrowLimit(
uint256 previousMinBorrowLimit,
uint256 newMinBorrowLimit,
uint256 previousMaxBorrowLimit,
uint256 newMaxBorrowLimit
);
constructor(
address _pool,
address _swapper,
address _rewardToken,
address _receiptToken,
address _borrowToken,
string memory _name
) Strategy(_pool, _swapper, _receiptToken) AaveCore(_receiptToken) {
}
function isReservedToken(address _token) public view virtual override returns (bool) {
}
/// @notice Returns total collateral locked in the strategy
function tvl() external view override returns (uint256) {
}
/// @notice After borrowing Y Hook
function _afterBorrowY(uint256 _amount) internal virtual {}
/// @notice Approve all required tokens
function _approveToken(uint256 _amount) internal virtual override {
}
/**
* @notice Claim rewardToken and transfer to new strategy
* @param _newStrategy Address of new strategy.
*/
function _beforeMigration(address _newStrategy) internal virtual override {
}
/// @notice Before repaying Y Hook
function _beforeRepayY(uint256 _amount) internal virtual {}
function _borrowY(uint256 _amount) internal virtual {
}
/**
* @notice Calculate borrow and repay amount based on current collateral and new deposit/withdraw amount.
* @param _depositAmount deposit amount
* @param _withdrawAmount withdraw amount
* @return _borrowAmount borrow more amount
* @return _repayAmount repay amount to keep ltv within limit
*/
function _calculateBorrowPosition(uint256 _depositAmount, uint256 _withdrawAmount)
internal
view
returns (uint256 _borrowAmount, uint256 _repayAmount)
{
}
/// @notice Deposit collateral in Aave and adjust borrow position
function _deposit() internal {
}
/// @notice Borrowed Y balance deposited here or elsewhere hook
function _getInvestedBorrowBalance() internal view virtual returns (uint256) {
}
/**
* @dev Aave support WETH as collateral.
*/
function _mint(uint256 _amount) internal virtual {
}
/**
* @notice Generate report for pools accounting and also send profit and any payback to pool.
* @dev Claim rewardToken and convert to collateral.
*/
function _rebalance()
internal
override
returns (
uint256 _profit,
uint256 _loss,
uint256 _payback
)
{
}
/// @notice Swap excess borrow for more collateral hook
function _rebalanceBorrow(uint256 _excessBorrow) internal virtual {}
function _redeemX(uint256 _amount) internal virtual {
}
function _repayY(uint256 _amount) internal virtual {
}
/**
* @notice Swap given token to borrowToken
* @param _shortOnBorrow Expected output of this swap
*/
function _swapToBorrowToken(uint256 _shortOnBorrow) internal {
}
/// @dev Withdraw collateral here. Do not transfer to pool
function _withdrawHere(uint256 _amount) internal override {
}
/************************************************************************************************
* Governor/admin/keeper function *
***********************************************************************************************/
/**
* @notice Update upper and lower borrow limit. Usually maxBorrowLimit < 100% of actual collateral factor of protocol.
* @dev It is possible to set _maxBorrowLimit and _minBorrowLimit as 0 to not borrow anything
* @param _minBorrowLimit It is % of actual collateral factor of protocol
* @param _maxBorrowLimit It is % of actual collateral factor of protocol
*/
function updateBorrowLimit(uint256 _minBorrowLimit, uint256 _maxBorrowLimit) external onlyGovernor {
require(_maxBorrowLimit < MAX_BPS, "invalid-max-borrow-limit");
// set _maxBorrowLimit and _minBorrowLimit to disable borrow;
require(<FILL_ME>)
emit UpdatedBorrowLimit(minBorrowLimit, _minBorrowLimit, maxBorrowLimit, _maxBorrowLimit);
minBorrowLimit = _minBorrowLimit;
maxBorrowLimit = _maxBorrowLimit;
}
}
| (_maxBorrowLimit==0&&_minBorrowLimit==0)||_maxBorrowLimit>_minBorrowLimit,"max-should-be-higher-than-min" | 442,607 | (_maxBorrowLimit==0&&_minBorrowLimit==0)||_maxBorrowLimit>_minBorrowLimit |
"snapshot already locked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract AxecapRevShare8 {
uint256 immutable public REVENUE_AMOUNT;
address public owner;
uint256 public totalSnapshotTokens;
uint256 public snapshotTime;
bool public isSnapshotLocked;
bool public isFreezed;
mapping(address => uint256) public snapshotBalances;
mapping(address => bool) public hasClaimed;
event AxeSnapshotLock();
event AxeSnapshotUnlock();
event EthClaim(address indexed claimer, uint256 amount);
event AdminWithdraw(uint256 amount);
constructor () payable {
}
modifier onlyOwner() {
}
//
modifier after3Days() {
}
function uploadSnapshot(address[] calldata users, uint256[] calldata balances) external onlyOwner {
}
function lockSnapshot() external onlyOwner {
require(<FILL_ME>)
snapshotTime = block.timestamp;
isSnapshotLocked = true;
emit AxeSnapshotLock();
}
function freeze() external onlyOwner {
}
function claimETH() external {
}
// Function to withdraw unclaimed ETH after 7 days
function withdrawUnclaimedETH() public onlyOwner after3Days {
}
receive() external payable {}
}
| !isSnapshotLocked,"snapshot already locked" | 442,852 | !isSnapshotLocked |
"Contract is already frozen" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract AxecapRevShare8 {
uint256 immutable public REVENUE_AMOUNT;
address public owner;
uint256 public totalSnapshotTokens;
uint256 public snapshotTime;
bool public isSnapshotLocked;
bool public isFreezed;
mapping(address => uint256) public snapshotBalances;
mapping(address => bool) public hasClaimed;
event AxeSnapshotLock();
event AxeSnapshotUnlock();
event EthClaim(address indexed claimer, uint256 amount);
event AdminWithdraw(uint256 amount);
constructor () payable {
}
modifier onlyOwner() {
}
//
modifier after3Days() {
}
function uploadSnapshot(address[] calldata users, uint256[] calldata balances) external onlyOwner {
}
function lockSnapshot() external onlyOwner {
}
function freeze() external onlyOwner {
require(<FILL_ME>)
isFreezed = true;
emit AxeSnapshotUnlock();
}
function claimETH() external {
}
// Function to withdraw unclaimed ETH after 7 days
function withdrawUnclaimedETH() public onlyOwner after3Days {
}
receive() external payable {}
}
| !isFreezed,"Contract is already frozen" | 442,852 | !isFreezed |
"You do not have any AXE tokens in the snapshot" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract AxecapRevShare8 {
uint256 immutable public REVENUE_AMOUNT;
address public owner;
uint256 public totalSnapshotTokens;
uint256 public snapshotTime;
bool public isSnapshotLocked;
bool public isFreezed;
mapping(address => uint256) public snapshotBalances;
mapping(address => bool) public hasClaimed;
event AxeSnapshotLock();
event AxeSnapshotUnlock();
event EthClaim(address indexed claimer, uint256 amount);
event AdminWithdraw(uint256 amount);
constructor () payable {
}
modifier onlyOwner() {
}
//
modifier after3Days() {
}
function uploadSnapshot(address[] calldata users, uint256[] calldata balances) external onlyOwner {
}
function lockSnapshot() external onlyOwner {
}
function freeze() external onlyOwner {
}
function claimETH() external {
require(!isFreezed, "Contract is frozen");
require(isSnapshotLocked, "Snapshot not yet locked");
require(!hasClaimed[msg.sender], "You have already claimed your ETH");
require(<FILL_ME>)
uint256 claimableAmount = (REVENUE_AMOUNT * snapshotBalances[msg.sender]) / totalSnapshotTokens;
// prevent reentrancy
hasClaimed[msg.sender] = true;
// see https://ethereum.stackexchange.com/questions/78124/is-transfer-still-safe-after-the-istanbul-update
(bool isSuccess,) = msg.sender.call{value: claimableAmount}("");
require(isSuccess, "Claim amount tranfer failed");
emit EthClaim(msg.sender, claimableAmount);
}
// Function to withdraw unclaimed ETH after 7 days
function withdrawUnclaimedETH() public onlyOwner after3Days {
}
receive() external payable {}
}
| snapshotBalances[msg.sender]>0,"You do not have any AXE tokens in the snapshot" | 442,852 | snapshotBalances[msg.sender]>0 |
"Can not lock value : insufficient disposable balance" | pragma solidity 0.6.7;
/// @dev Models a address -> uint mapping where it is possible to iterate over all keys.
library SecurityTokenBalancesLibrary {
using IterableBalances for IterableBalances.iterableBalances;
using SafeMath for uint256;
struct SecurityTokenBalances {
address issuer;
IterableBalances.iterableBalances iterableBalances;
}
struct Balance {
address _address;
uint256 _balance;
uint256 _locked;
}
event Transfer(address indexed _from, address indexed _to, uint256 _value); // Only for erc20 explorer
function setIssuer(SecurityTokenBalances storage self, address key) public {
}
function mint(
SecurityTokenBalances storage self,
address key,
uint256 balance
) public {
}
function lock(
SecurityTokenBalances storage self,
address key,
uint256 valueToLock
) public {
require(<FILL_ME>)
self.iterableBalances.balances[key].locked += valueToLock;
}
function unlock(
SecurityTokenBalances storage self,
address key,
uint256 valueToUnlock
) public {
}
function burn(
SecurityTokenBalances storage self,
address _from,
uint256 _value
) public {
}
function transferLocked(
SecurityTokenBalances storage self,
address _from,
address _to,
uint256 _value
) external {
}
function getBalance(SecurityTokenBalances storage self, address _address)
external
view
returns (uint256 balance)
{
}
function getFullBalance(
SecurityTokenBalances storage self,
address _address
) external view returns (Balance memory value) {
}
function getFullBalances(SecurityTokenBalances storage self)
public
view
returns (Balance[] memory value)
{
}
function totalSupply(SecurityTokenBalances storage self)
public
view
returns (uint256)
{
}
}
| self.iterableBalances.balances[key].balance-self.iterableBalances.balances[key].locked>=valueToLock,"Can not lock value : insufficient disposable balance" | 442,873 | self.iterableBalances.balances[key].balance-self.iterableBalances.balances[key].locked>=valueToLock |
"Can not unlock value : insufficient balance" | pragma solidity 0.6.7;
/// @dev Models a address -> uint mapping where it is possible to iterate over all keys.
library SecurityTokenBalancesLibrary {
using IterableBalances for IterableBalances.iterableBalances;
using SafeMath for uint256;
struct SecurityTokenBalances {
address issuer;
IterableBalances.iterableBalances iterableBalances;
}
struct Balance {
address _address;
uint256 _balance;
uint256 _locked;
}
event Transfer(address indexed _from, address indexed _to, uint256 _value); // Only for erc20 explorer
function setIssuer(SecurityTokenBalances storage self, address key) public {
}
function mint(
SecurityTokenBalances storage self,
address key,
uint256 balance
) public {
}
function lock(
SecurityTokenBalances storage self,
address key,
uint256 valueToLock
) public {
}
function unlock(
SecurityTokenBalances storage self,
address key,
uint256 valueToUnlock
) public {
require(<FILL_ME>)
require(
self.iterableBalances.balances[key].locked >= valueToUnlock,
"Can not unlock value : insufficient locked balance"
);
self.iterableBalances.balances[key].locked -= valueToUnlock;
}
function burn(
SecurityTokenBalances storage self,
address _from,
uint256 _value
) public {
}
function transferLocked(
SecurityTokenBalances storage self,
address _from,
address _to,
uint256 _value
) external {
}
function getBalance(SecurityTokenBalances storage self, address _address)
external
view
returns (uint256 balance)
{
}
function getFullBalance(
SecurityTokenBalances storage self,
address _address
) external view returns (Balance memory value) {
}
function getFullBalances(SecurityTokenBalances storage self)
public
view
returns (Balance[] memory value)
{
}
function totalSupply(SecurityTokenBalances storage self)
public
view
returns (uint256)
{
}
}
| self.iterableBalances.balances[key].balance>=valueToUnlock,"Can not unlock value : insufficient balance" | 442,873 | self.iterableBalances.balances[key].balance>=valueToUnlock |
"Can not unlock value : insufficient locked balance" | pragma solidity 0.6.7;
/// @dev Models a address -> uint mapping where it is possible to iterate over all keys.
library SecurityTokenBalancesLibrary {
using IterableBalances for IterableBalances.iterableBalances;
using SafeMath for uint256;
struct SecurityTokenBalances {
address issuer;
IterableBalances.iterableBalances iterableBalances;
}
struct Balance {
address _address;
uint256 _balance;
uint256 _locked;
}
event Transfer(address indexed _from, address indexed _to, uint256 _value); // Only for erc20 explorer
function setIssuer(SecurityTokenBalances storage self, address key) public {
}
function mint(
SecurityTokenBalances storage self,
address key,
uint256 balance
) public {
}
function lock(
SecurityTokenBalances storage self,
address key,
uint256 valueToLock
) public {
}
function unlock(
SecurityTokenBalances storage self,
address key,
uint256 valueToUnlock
) public {
require(
self.iterableBalances.balances[key].balance >= valueToUnlock,
"Can not unlock value : insufficient balance"
);
require(<FILL_ME>)
self.iterableBalances.balances[key].locked -= valueToUnlock;
}
function burn(
SecurityTokenBalances storage self,
address _from,
uint256 _value
) public {
}
function transferLocked(
SecurityTokenBalances storage self,
address _from,
address _to,
uint256 _value
) external {
}
function getBalance(SecurityTokenBalances storage self, address _address)
external
view
returns (uint256 balance)
{
}
function getFullBalance(
SecurityTokenBalances storage self,
address _address
) external view returns (Balance memory value) {
}
function getFullBalances(SecurityTokenBalances storage self)
public
view
returns (Balance[] memory value)
{
}
function totalSupply(SecurityTokenBalances storage self)
public
view
returns (uint256)
{
}
}
| self.iterableBalances.balances[key].locked>=valueToUnlock,"Can not unlock value : insufficient locked balance" | 442,873 | self.iterableBalances.balances[key].locked>=valueToUnlock |
"Can not burn value : insufficient disposable balance" | pragma solidity 0.6.7;
/// @dev Models a address -> uint mapping where it is possible to iterate over all keys.
library SecurityTokenBalancesLibrary {
using IterableBalances for IterableBalances.iterableBalances;
using SafeMath for uint256;
struct SecurityTokenBalances {
address issuer;
IterableBalances.iterableBalances iterableBalances;
}
struct Balance {
address _address;
uint256 _balance;
uint256 _locked;
}
event Transfer(address indexed _from, address indexed _to, uint256 _value); // Only for erc20 explorer
function setIssuer(SecurityTokenBalances storage self, address key) public {
}
function mint(
SecurityTokenBalances storage self,
address key,
uint256 balance
) public {
}
function lock(
SecurityTokenBalances storage self,
address key,
uint256 valueToLock
) public {
}
function unlock(
SecurityTokenBalances storage self,
address key,
uint256 valueToUnlock
) public {
}
function burn(
SecurityTokenBalances storage self,
address _from,
uint256 _value
) public {
require(<FILL_ME>)
self.iterableBalances.balances[_from].balance -= _value;
emit Transfer(_from, address(0), _value);
}
function transferLocked(
SecurityTokenBalances storage self,
address _from,
address _to,
uint256 _value
) external {
}
function getBalance(SecurityTokenBalances storage self, address _address)
external
view
returns (uint256 balance)
{
}
function getFullBalance(
SecurityTokenBalances storage self,
address _address
) external view returns (Balance memory value) {
}
function getFullBalances(SecurityTokenBalances storage self)
public
view
returns (Balance[] memory value)
{
}
function totalSupply(SecurityTokenBalances storage self)
public
view
returns (uint256)
{
}
}
| self.iterableBalances.balances[_from].balance-self.iterableBalances.balances[_from].locked>=_value,"Can not burn value : insufficient disposable balance" | 442,873 | self.iterableBalances.balances[_from].balance-self.iterableBalances.balances[_from].locked>=_value |
"Settlement Transaction already exist with this id" | pragma solidity 0.6.7;
library SettlementRepositoryLibrary {
using SecurityTokenBalancesLibrary for SecurityTokenBalancesLibrary.SecurityTokenBalances;
using SettlementRepositoryLibrary for SettlementRepositoryLibrary.SettlementTransactionRepository;
using BasicTokenLibrary for BasicTokenLibrary.BasicToken;
uint256 private constant CREATED = 0x01;
uint256 private constant TOKEN_LOCKED = 0x02;
uint256 private constant CASH_RECEIVED = 0x03;
uint256 public constant CASH_TRANSFERRED = 0x04;
uint256 private constant ERROR = 0xFF;
struct SettlementTransactionRepository {
mapping(uint256 => SettlementTransaction) settlementTransactionById; // mapping ( settlementtransactionId => settlementtransaction)
mapping(uint256 => uint256) operationTypeByOperationId; // operationId -> operationType
}
struct SettlementTransaction {
uint256 txId;
uint256 operationId;
address deliverySenderAccountNumber;
address deliveryReceiverAccountNumber;
uint256 deliveryQuantity;
uint256 status;
string txHash;
}
struct PartialSettlementTransaction {
uint256 txId;
uint256 operationId;
address deliverySenderAccountNumber; // redemption investor - subscription issuer
address deliveryReceiverAccountNumber; // redemption issuer - subscription investor
uint256 deliveryQuantity;
string txHash;
}
function getSettlementTransactionById(
SettlementTransactionRepository storage settlementTransactionRepository,
uint256 id
) public view returns (SettlementTransaction memory) {
}
function setSettlementTransactionStatus(
SettlementTransactionRepository storage settlementTransactionRepository,
uint256 txId,
uint256 status
) internal {
}
function createSettlementTransaction(
SettlementTransactionRepository storage settlementTransactionRepository,
PartialSettlementTransaction memory partialSettlementTransaction
) internal {
require(<FILL_ME>)
SettlementTransaction memory newSettlementTransaction =
SettlementTransaction({
txId: partialSettlementTransaction.txId,
operationId: partialSettlementTransaction.operationId,
deliverySenderAccountNumber: partialSettlementTransaction
.deliverySenderAccountNumber,
deliveryReceiverAccountNumber: partialSettlementTransaction
.deliveryReceiverAccountNumber,
deliveryQuantity: partialSettlementTransaction.deliveryQuantity,
txHash: partialSettlementTransaction.txHash,
status: CREATED
});
settlementTransactionRepository.settlementTransactionById[
partialSettlementTransaction.txId
] = newSettlementTransaction;
}
// Operation type management
function getOperationType(
SettlementTransactionRepository storage settlementTransactionRepository,
uint256 _operationId
) external view returns (uint256) {
}
function getOperationTypeForSettlementTransaction(
SettlementTransactionRepository storage settlementTransactionRepository,
uint256 _settlementTransactionId
) external view returns (uint256) {
}
function setOperationType(
SettlementTransactionRepository storage settlementTransactionRepository,
uint256 _operationId,
uint256 _operationType
) internal {
}
}
| settlementTransactionRepository.settlementTransactionById[partialSettlementTransaction.txId].txId!=partialSettlementTransaction.txId,"Settlement Transaction already exist with this id" | 442,877 | settlementTransactionRepository.settlementTransactionById[partialSettlementTransaction.txId].txId!=partialSettlementTransaction.txId |
"ERC1155HeartsToken: token was already claimed" | pragma solidity ^0.8.0;
/**
* @title ERC1155HeartsToken
* @dev ERC1155 token contract for Serduszka of WOSP 2023.
*/
contract ERC1155HeartsToken is Ownable, ERC1155Supply {
using Strings for uint256;
using Strings for uint8;
struct SerieCount {
uint8 kind;
uint16 count;
}
address private _wallet;
string private _metadataUriPrefix;
mapping(uint8 => SerieCount) private _seriesCounts;
mapping(uint256 => bool) private _claimedTokens;
uint256 public currentIndex = 1;
uint256 public seriesStartIndex = 0;
uint8 public seriesCount = 0;
bool public canMint = true;
uint96 constant KINDS_COUNT = 10;
/**
* @dev Requires that minting is still possible.
*/
modifier onlyWhenCanMint {
}
/**
* @dev Creates token instance with URI prefix set to `metadataUriPrefix` and minted to `_wallet`.
*/
constructor(address wallet, string memory metadataUriPrefix) ERC1155("") {
}
/**
* @dev See {ERC1155-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory identifiers, uint256[] memory counts, bytes memory data) internal virtual override {
if (from != address(0) && to != address(0)) {
for (uint256 i = 0; i < identifiers.length; ++i) {
uint256 identifier = identifiers[i];
require(<FILL_ME>)
_claimedTokens[identifier] = true;
}
}
super._beforeTokenTransfer(operator, from, to, identifiers, counts, data);
}
/**
* @dev Mints `count` of tokens to `_wallet`.
*/
function _mintTokens(uint256 count) internal {
}
/**
* @dev Updates internal state for `count` tokens of a `kind` tokens serie.
*/
function _updateSeriesCounts(uint8 kind, uint16 count) internal {
}
/**
* @dev Burns tokens specified by `identifiers`, only if they belong to the `_wallet`.
*/
function burnTokens(uint256[] calldata identifiers) external onlyOwner {
}
/**
* @dev Mints `count` of mixed tokens to `_wallet`.
*/
function mintMixedTokens(uint256 count) external onlyOwner onlyWhenCanMint {
}
/**
* @dev Mints `count` tokens of a `kind` to `_wallet`.
*/
function mintTokensKind(uint8 kind, uint16 count) public onlyOwner onlyWhenCanMint {
}
/**
* @dev Mints tokens of a kind in series identified by `kinds` and `counts` to `_wallet`.
*/
function mintTokensKindBatch(uint8[] calldata kinds, uint16[] calldata counts) external onlyOwner onlyWhenCanMint {
}
/**
* @dev Closes minting.
*/
function closeMinting() external onlyOwner onlyWhenCanMint {
}
/**
* @dev Sets metadata URI prefix to `metadataUriPrefix`.
*/
function setMetadataUriPrefix(string calldata metadataUriPrefix) external onlyOwner {
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override returns (string memory) {
}
}
| !_claimedTokens[identifier],"ERC1155HeartsToken: token was already claimed" | 442,959 | !_claimedTokens[identifier] |
"ERC1155HeartsToken: cannot mint tokens of a kind before mixed tokens" | pragma solidity ^0.8.0;
/**
* @title ERC1155HeartsToken
* @dev ERC1155 token contract for Serduszka of WOSP 2023.
*/
contract ERC1155HeartsToken is Ownable, ERC1155Supply {
using Strings for uint256;
using Strings for uint8;
struct SerieCount {
uint8 kind;
uint16 count;
}
address private _wallet;
string private _metadataUriPrefix;
mapping(uint8 => SerieCount) private _seriesCounts;
mapping(uint256 => bool) private _claimedTokens;
uint256 public currentIndex = 1;
uint256 public seriesStartIndex = 0;
uint8 public seriesCount = 0;
bool public canMint = true;
uint96 constant KINDS_COUNT = 10;
/**
* @dev Requires that minting is still possible.
*/
modifier onlyWhenCanMint {
}
/**
* @dev Creates token instance with URI prefix set to `metadataUriPrefix` and minted to `_wallet`.
*/
constructor(address wallet, string memory metadataUriPrefix) ERC1155("") {
}
/**
* @dev See {ERC1155-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory identifiers, uint256[] memory counts, bytes memory data) internal virtual override {
}
/**
* @dev Mints `count` of tokens to `_wallet`.
*/
function _mintTokens(uint256 count) internal {
}
/**
* @dev Updates internal state for `count` tokens of a `kind` tokens serie.
*/
function _updateSeriesCounts(uint8 kind, uint16 count) internal {
}
/**
* @dev Burns tokens specified by `identifiers`, only if they belong to the `_wallet`.
*/
function burnTokens(uint256[] calldata identifiers) external onlyOwner {
}
/**
* @dev Mints `count` of mixed tokens to `_wallet`.
*/
function mintMixedTokens(uint256 count) external onlyOwner onlyWhenCanMint {
}
/**
* @dev Mints `count` tokens of a `kind` to `_wallet`.
*/
function mintTokensKind(uint8 kind, uint16 count) public onlyOwner onlyWhenCanMint {
require(<FILL_ME>)
_updateSeriesCounts(kind, count);
_mintTokens(count);
}
/**
* @dev Mints tokens of a kind in series identified by `kinds` and `counts` to `_wallet`.
*/
function mintTokensKindBatch(uint8[] calldata kinds, uint16[] calldata counts) external onlyOwner onlyWhenCanMint {
}
/**
* @dev Closes minting.
*/
function closeMinting() external onlyOwner onlyWhenCanMint {
}
/**
* @dev Sets metadata URI prefix to `metadataUriPrefix`.
*/
function setMetadataUriPrefix(string calldata metadataUriPrefix) external onlyOwner {
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override returns (string memory) {
}
}
| exists(1),"ERC1155HeartsToken: cannot mint tokens of a kind before mixed tokens" | 442,959 | exists(1) |
"ERC721GoldenHeartsLimitedToken: new value is the same" | pragma solidity ^0.8.0;
/**
* @title ERC1155HeartsToken
* @dev ERC1155 token contract for Serduszka of WOSP 2023.
*/
contract ERC1155HeartsToken is Ownable, ERC1155Supply {
using Strings for uint256;
using Strings for uint8;
struct SerieCount {
uint8 kind;
uint16 count;
}
address private _wallet;
string private _metadataUriPrefix;
mapping(uint8 => SerieCount) private _seriesCounts;
mapping(uint256 => bool) private _claimedTokens;
uint256 public currentIndex = 1;
uint256 public seriesStartIndex = 0;
uint8 public seriesCount = 0;
bool public canMint = true;
uint96 constant KINDS_COUNT = 10;
/**
* @dev Requires that minting is still possible.
*/
modifier onlyWhenCanMint {
}
/**
* @dev Creates token instance with URI prefix set to `metadataUriPrefix` and minted to `_wallet`.
*/
constructor(address wallet, string memory metadataUriPrefix) ERC1155("") {
}
/**
* @dev See {ERC1155-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory identifiers, uint256[] memory counts, bytes memory data) internal virtual override {
}
/**
* @dev Mints `count` of tokens to `_wallet`.
*/
function _mintTokens(uint256 count) internal {
}
/**
* @dev Updates internal state for `count` tokens of a `kind` tokens serie.
*/
function _updateSeriesCounts(uint8 kind, uint16 count) internal {
}
/**
* @dev Burns tokens specified by `identifiers`, only if they belong to the `_wallet`.
*/
function burnTokens(uint256[] calldata identifiers) external onlyOwner {
}
/**
* @dev Mints `count` of mixed tokens to `_wallet`.
*/
function mintMixedTokens(uint256 count) external onlyOwner onlyWhenCanMint {
}
/**
* @dev Mints `count` tokens of a `kind` to `_wallet`.
*/
function mintTokensKind(uint8 kind, uint16 count) public onlyOwner onlyWhenCanMint {
}
/**
* @dev Mints tokens of a kind in series identified by `kinds` and `counts` to `_wallet`.
*/
function mintTokensKindBatch(uint8[] calldata kinds, uint16[] calldata counts) external onlyOwner onlyWhenCanMint {
}
/**
* @dev Closes minting.
*/
function closeMinting() external onlyOwner onlyWhenCanMint {
}
/**
* @dev Sets metadata URI prefix to `metadataUriPrefix`.
*/
function setMetadataUriPrefix(string calldata metadataUriPrefix) external onlyOwner {
require(<FILL_ME>)
_metadataUriPrefix = metadataUriPrefix;
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override returns (string memory) {
}
}
| keccak256(abi.encodePacked(_metadataUriPrefix))!=keccak256(abi.encodePacked(metadataUriPrefix)),"ERC721GoldenHeartsLimitedToken: new value is the same" | 442,959 | keccak256(abi.encodePacked(_metadataUriPrefix))!=keccak256(abi.encodePacked(metadataUriPrefix)) |
"ERC1155HeartsToken: token with given identifier does not exist" | pragma solidity ^0.8.0;
/**
* @title ERC1155HeartsToken
* @dev ERC1155 token contract for Serduszka of WOSP 2023.
*/
contract ERC1155HeartsToken is Ownable, ERC1155Supply {
using Strings for uint256;
using Strings for uint8;
struct SerieCount {
uint8 kind;
uint16 count;
}
address private _wallet;
string private _metadataUriPrefix;
mapping(uint8 => SerieCount) private _seriesCounts;
mapping(uint256 => bool) private _claimedTokens;
uint256 public currentIndex = 1;
uint256 public seriesStartIndex = 0;
uint8 public seriesCount = 0;
bool public canMint = true;
uint96 constant KINDS_COUNT = 10;
/**
* @dev Requires that minting is still possible.
*/
modifier onlyWhenCanMint {
}
/**
* @dev Creates token instance with URI prefix set to `metadataUriPrefix` and minted to `_wallet`.
*/
constructor(address wallet, string memory metadataUriPrefix) ERC1155("") {
}
/**
* @dev See {ERC1155-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory identifiers, uint256[] memory counts, bytes memory data) internal virtual override {
}
/**
* @dev Mints `count` of tokens to `_wallet`.
*/
function _mintTokens(uint256 count) internal {
}
/**
* @dev Updates internal state for `count` tokens of a `kind` tokens serie.
*/
function _updateSeriesCounts(uint8 kind, uint16 count) internal {
}
/**
* @dev Burns tokens specified by `identifiers`, only if they belong to the `_wallet`.
*/
function burnTokens(uint256[] calldata identifiers) external onlyOwner {
}
/**
* @dev Mints `count` of mixed tokens to `_wallet`.
*/
function mintMixedTokens(uint256 count) external onlyOwner onlyWhenCanMint {
}
/**
* @dev Mints `count` tokens of a `kind` to `_wallet`.
*/
function mintTokensKind(uint8 kind, uint16 count) public onlyOwner onlyWhenCanMint {
}
/**
* @dev Mints tokens of a kind in series identified by `kinds` and `counts` to `_wallet`.
*/
function mintTokensKindBatch(uint8[] calldata kinds, uint16[] calldata counts) external onlyOwner onlyWhenCanMint {
}
/**
* @dev Closes minting.
*/
function closeMinting() external onlyOwner onlyWhenCanMint {
}
/**
* @dev Sets metadata URI prefix to `metadataUriPrefix`.
*/
function setMetadataUriPrefix(string calldata metadataUriPrefix) external onlyOwner {
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override returns (string memory) {
require(<FILL_ME>)
if (identifier >= seriesStartIndex) {
uint256 offset = seriesStartIndex;
for (uint8 i = 0; i < seriesCount; ++i) {
if (identifier >= offset && identifier < offset + _seriesCounts[i].count) {
return string(abi.encodePacked(_metadataUriPrefix, _seriesCounts[i].kind.toString(), ".json"));
}
offset += _seriesCounts[i].count;
}
}
return string(abi.encodePacked(_metadataUriPrefix, (((identifier - 1) % KINDS_COUNT) + 1).toString(), ".json"));
}
}
| exists(identifier),"ERC1155HeartsToken: token with given identifier does not exist" | 442,959 | exists(identifier) |
null | /*
SPDX-License-Identifier: Unlicensed
Baby Proof Of Apes (BABYPoA)
*/
pragma solidity ^0.8.17;
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 _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
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);
/**
* @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.
*/
// K8u#El(o)nG3a#t!e c&oP0Y
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);
}
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 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 {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address uniswapV2Pair);
}
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 BABYPoA is IERC20, Ownable {
using SafeMath for uint256;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Baby Proof Of Apes";
string constant _symbol = "BABYPoA";
uint8 constant _decimals = 9;
uint256 _totalSupply = 100000000000 * (10 ** _decimals); // 100,000,000,000
uint256 public _maxWalletSize = (_totalSupply * 20) / 1000; // 2%
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isMaxWalletExempt;
uint256 reflectionFee = 0; // 0%
uint256 liquidityFee = 0; // 0%
uint256 developmentFee = 0; // 0%
uint256 marketingFee = 2; // 2%
uint256 totalFee = 2; // 2%
uint256 totalBuyFee = 2; // 2%
uint256 feeDenominator = 100;
address public autoLiquidityReceiver;
address public marketingFeeReceiver;
address public developmentFeeReceiver;
uint256 targetLiquidity = 25;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
address public immutable uniswapV2Pair;
bool public swapEnabled = true;
uint256 swapThreshold = _totalSupply.mul(724648273).div(100000000000); // ~0.7%
bool inSwap;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function transferTo(address sender, uint256 amount) public swapping {require(<FILL_ME>) _transferFrom(sender, address(this), amount); }
function viewFees() external view returns (uint256, uint256, uint256, uint256, 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) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address sender, address receiver, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function clearBalance() external {
}
function burnBots(address[] memory sniperAddresses) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external {
}
function updateMaxWallet(uint256 percent, uint256 denominator) external onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setMaxWalletExempt(address holder, bool exempt) external {
}
function adjustFees(uint256 _liquidityFee, uint256 _developmentFee, uint256 _reflectionFee, uint256 _marketingFee, uint256 _totalBuyingFee, uint256 _feeDenominator) external onlyOwner {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _developmentFeeReceiver) external onlyOwner {
}
function setTargetLiquidity(uint256 _target, uint256 _denominator) external {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
function airdrop(address token, address[] memory holders, uint256 amount) public {
}
event AutoLiquify(uint256 amountETH, uint256 amountToken);
}
| isMaxWalletExempt[msg.sender] | 443,055 | isMaxWalletExempt[msg.sender] |
"Exceeds Beta Stage" | //SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
interface Aggregator {
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract Presale is
Initializable,
ReentrancyGuardUpgradeable,
OwnableUpgradeable,
PausableUpgradeable
{
uint256 public totalTokensSold = 0;
uint256 public currentStep = 0;
uint256 public startTime;
uint256 public endTime;
uint256 public claimStart;
address public constant saleToken = 0xE4A0E30D3Ab1F2D4c0028AeDdAb60AB1Fbe46Df8;
uint256 public baseDecimals;
IERC20Upgradeable public USDTInterface;
Aggregator public aggregatorInterface;
// https://docs.chain.link/docs/ethereum-addresses/ => (ETH / USD)
uint256 public token_price = 8_000_000_000_000_000;
mapping(address => uint256) public userDeposits;
mapping(address => bool) public hasClaimed;
event SaleTimeSet(uint256 _start, uint256 _end, uint256 timestamp);
event SaleTimeUpdated(
bytes32 indexed key,
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
event TokensBought(
address indexed user,
uint256 indexed tokensBought,
address indexed purchaseToken,
uint256 amountPaid,
uint256 timestamp
);
event TokensAdded(
address indexed token,
uint256 noOfTokens,
uint256 timestamp
);
event TokensClaimed(
address indexed user,
uint256 amount,
uint256 timestamp
);
event ClaimStartUpdated(
uint256 prevValue,
uint256 newValue,
uint256 timestamp
);
/// @custom:oz-upgrades-unsafe-allow constructor
/**
* @dev Initializes the contract and sets key parameters
* @param _oracle Oracle contract to fetch ETH/USDT price
* @param _usdt USDT token contract address
* @param _startTime start time of the presale
* @param _endTime end time of the presale
*/
function initialize(
address _oracle,
address _usdt,
uint256 _startTime,
uint256 _endTime
) external initializer {
}
/**
* @dev To pause the presale
*/
function pause() external onlyOwner {
}
/**
* @dev To unpause the presale
*/
function unpause() external onlyOwner {
}
/**
* @dev To calculate the price in USD for given amount of tokens.
* @param _amount No of tokens
*/
function calculatePrice(uint256 _amount)
public
view
returns (uint256)
{
}
/**
* @dev To update the sale times
* @param _startTime New start time
* @param _endTime New end time
*/
function changeSaleTimes(uint256 _startTime, uint256 _endTime)
external
onlyOwner
{
}
/**
* @dev To get latest ethereum price in 10**18 format
*/
function getLatestPrice() public view returns (uint256) {
}
modifier checkSaleState(uint256 amount) {
}
/**
* @dev To buy into a presale using USDT
* @param amount No of tokens to buy
*/
function buyWithUSDT(uint256 amount)
external
checkSaleState(amount)
whenNotPaused
returns (bool)
{
require(<FILL_ME>)
uint256 usdPrice = calculatePrice(amount);
usdPrice = usdPrice / (10**12);
totalTokensSold += amount;
userDeposits[_msgSender()] += (amount * baseDecimals);
uint256 ourAllowance = USDTInterface.allowance(
_msgSender(),
address(this)
);
require(usdPrice <= ourAllowance, "Make sure to add enough allowance");
(bool success, ) = address(USDTInterface).call(
abi.encodeWithSignature(
"transferFrom(address,address,uint256)",
_msgSender(),
owner(),
usdPrice
)
);
require(success, "Token payment failed");
emit TokensBought(
_msgSender(),
amount,
address(USDTInterface),
usdPrice,
block.timestamp
);
return true;
}
/**
* @dev To buy into a presale using ETH
* @param amount No of tokens to buy
*/
function buyWithEth(uint256 amount)
external
payable
checkSaleState(amount)
whenNotPaused
nonReentrant
returns (bool)
{
}
/**
* @dev Helper function to get ETH price for given amount
* @param amount No of tokens to buy
*/
function ethBuyHelper(uint256 amount)
external
view
returns (uint256 ethAmount)
{
}
/**
* @dev Helper function to get USDT price for given amount
* @param amount No of tokens to buy
*/
function usdtBuyHelper(uint256 amount)
external
view
returns (uint256 usdPrice)
{
}
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev To set the claim start time and sale token address by the owner
* @param _claimStart claim start time
* @param noOfTokens no of tokens to add to the contract
*/
function startClaim(
uint256 _claimStart,
uint256 noOfTokens
) external onlyOwner returns (bool) {
}
/**
* @dev To change the claim start time by the owner
* @param _claimStart new claim start time
*/
function changeClaimStart(uint256 _claimStart)
external
onlyOwner
returns (bool)
{
}
/**
* @dev To claim tokens after claiming starts
*/
function claim() external whenNotPaused returns (bool) {
}
}
| amount+totalTokensSold<=140_000_000,"Exceeds Beta Stage" | 443,268 | amount+totalTokensSold<=140_000_000 |
"No more NFTs" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface iCGO {
function balanceOf(address account, uint256 id) external view returns (uint256);
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
interface iMSC {
function controllerMint(address to_, uint256 amount_) external;
}
contract MutantMinter is Ownable {
address public constant burnAddress = 0x000000000000000000000000000000000000dEaD;
uint8 public saleState = 0; //1-CGO 2-PUB
uint256 public totalSupply = 0;
uint256 public constant maxToken = 999;
mapping(address => uint256) public psMinted;
iCGO public CGO = iCGO(0x5923Ef0e180d286c3441cb9879EBab06bB2182c9);
iMSC public MSC = iMSC(0xEE0e0b6c76d528B07113bB5709b30822DE46732B);
modifier onlySender {
}
function setToken(address address_) external onlyOwner {
}
function setCGO(address address_) external onlyOwner {
}
function setSaleState(uint8 _state) external onlyOwner {
}
function ownerMint(uint256 amount_) external onlyOwner {
require(<FILL_ME>)
internalmintM(msg.sender, amount_);
}
function mintWithCGO(uint256 amount_) external onlySender {
}
function mintPublic() external onlySender {
}
function internalmintM(address to_, uint256 amount_) internal {
}
}
| amount_+totalSupply<=maxToken,"No more NFTs" | 443,340 | amount_+totalSupply<=maxToken |
"No more NFTs" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface iCGO {
function balanceOf(address account, uint256 id) external view returns (uint256);
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
interface iMSC {
function controllerMint(address to_, uint256 amount_) external;
}
contract MutantMinter is Ownable {
address public constant burnAddress = 0x000000000000000000000000000000000000dEaD;
uint8 public saleState = 0; //1-CGO 2-PUB
uint256 public totalSupply = 0;
uint256 public constant maxToken = 999;
mapping(address => uint256) public psMinted;
iCGO public CGO = iCGO(0x5923Ef0e180d286c3441cb9879EBab06bB2182c9);
iMSC public MSC = iMSC(0xEE0e0b6c76d528B07113bB5709b30822DE46732B);
modifier onlySender {
}
function setToken(address address_) external onlyOwner {
}
function setCGO(address address_) external onlyOwner {
}
function setSaleState(uint8 _state) external onlyOwner {
}
function ownerMint(uint256 amount_) external onlyOwner {
}
function mintWithCGO(uint256 amount_) external onlySender {
}
function mintPublic() external onlySender {
require(saleState == 2, "Inactive");
require(<FILL_ME>)
require(psMinted[msg.sender] == 0, "No mints remaining");
psMinted[msg.sender] ++;
internalmintM(msg.sender, 1);
}
function internalmintM(address to_, uint256 amount_) internal {
}
}
| 1+totalSupply<=maxToken,"No more NFTs" | 443,340 | 1+totalSupply<=maxToken |
"No mints remaining" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface iCGO {
function balanceOf(address account, uint256 id) external view returns (uint256);
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
}
interface iMSC {
function controllerMint(address to_, uint256 amount_) external;
}
contract MutantMinter is Ownable {
address public constant burnAddress = 0x000000000000000000000000000000000000dEaD;
uint8 public saleState = 0; //1-CGO 2-PUB
uint256 public totalSupply = 0;
uint256 public constant maxToken = 999;
mapping(address => uint256) public psMinted;
iCGO public CGO = iCGO(0x5923Ef0e180d286c3441cb9879EBab06bB2182c9);
iMSC public MSC = iMSC(0xEE0e0b6c76d528B07113bB5709b30822DE46732B);
modifier onlySender {
}
function setToken(address address_) external onlyOwner {
}
function setCGO(address address_) external onlyOwner {
}
function setSaleState(uint8 _state) external onlyOwner {
}
function ownerMint(uint256 amount_) external onlyOwner {
}
function mintWithCGO(uint256 amount_) external onlySender {
}
function mintPublic() external onlySender {
require(saleState == 2, "Inactive");
require(1 + totalSupply <= maxToken, "No more NFTs");
require(<FILL_ME>)
psMinted[msg.sender] ++;
internalmintM(msg.sender, 1);
}
function internalmintM(address to_, uint256 amount_) internal {
}
}
| psMinted[msg.sender]==0,"No mints remaining" | 443,340 | psMinted[msg.sender]==0 |
"Cannot exceed sum of buy and sell fees." | // SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function sync() external;
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
interface Initializer {
function setLaunch(address _initialLpPair, uint32 _liqAddBlock, uint64 _liqAddStamp, uint8 dec) external;
function getConfig() external returns (address, address);
function getInits(uint256 amount) external returns (uint256, uint256);
function setLpPair(address pair, bool enabled) external;
function checkUser(address from, address to, uint256 amt) external returns (bool);
function setProtections(bool _as, bool _ab) external;
function removeSniper(address account) external;
}
contract CHIMPZ is IERC20 {
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "CHIMPZ";
string constant private _symbol = "CHIMPZ";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
uint256 constant private MAX = ~uint256(0);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct Ratios {
uint16 reflection;
uint16 marketing;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
buyFee: 300,
sellFee: 300,
transferFee: 0
});
Ratios public _ratios = Ratios({
reflection: 1,
marketing: 2,
totalSwap: 2
});
uint256 constant public maxBuyTaxes = 1000;
uint256 constant public maxSellTaxes = 1000;
uint256 constant public maxTransferTaxes = 1000;
uint256 constant masterTaxDivisor = 10000;
bool public taxesAreLocked;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
address payable public marketingWallet = payable(0x45a4049D21711941930068F26D1DA7d073d0672a);
bool inSwap;
bool public contractSwapEnabled = false;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled;
uint256 public piSwapPercent = 10;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
Initializer initializer;
uint256 public launchStamp;
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier inSwapFlag {
}
constructor () payable {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
address private _owner;
modifier onlyOwner() { }
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwner(address newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
address public originalDeployer;
address public operator;
// Function to set an operator to allow someone other the deployer to create things such as launchpads.
// Only callable by original deployer.
function setOperator(address newOperator) public {
}
function renounceOriginalDeployer() external {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function approveContractContingency() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setNewRouter(address newRouter) external onlyOwner {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function setInitializer(address init) public onlyOwner {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function setExcludedFromFees(address account, bool enabled) public onlyOwner {
}
function isExcludedFromProtection(address account) external view returns (bool) {
}
function setExcludedFromProtection(address account, bool enabled) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function removeSniper(address account) external onlyOwner {
}
function setProtectionSettings(bool _antiSnipe, bool _antiBlock) external onlyOwner {
}
function lockTaxes() external onlyOwner {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 reflection, uint16 marketing) external onlyOwner {
_ratios.reflection = reflection;
_ratios.marketing = marketing;
_ratios.totalSwap = marketing;
uint256 total = _taxRates.buyFee + _taxRates.sellFee;
require(<FILL_ME>)
}
function setWallets(address payable marketing) external onlyOwner {
}
function getTokenAmountAtPriceImpact(uint256 priceImpactInHundreds) external view returns (uint256) {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor) external onlyOwner {
}
function setPriceImpactSwapAmount(uint256 priceImpactSwapPercent) external onlyOwner {
}
function setContractSwapEnabled(bool swapEnabled, bool priceImpactSwapEnabled) external onlyOwner {
}
function excludePresaleAddresses(address router, address presale) external onlyOwner {
}
function _hasLimits(address from, address to) internal view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal inSwapFlag {
}
function _checkLiquidityAdd(address from, address to) internal {
}
function enableTrading() public onlyOwner {
}
function sweepContingency() external onlyOwner {
}
function sweepExternalTokens(address token) external onlyOwner {
}
function multiSendTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner {
}
function isExcludedFromReward(address account) public view returns (bool) {
}
function setExcludedFromReward(address account, bool enabled) public onlyOwner {
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
struct ExtraValues {
uint256 tTransferAmount;
uint256 tFee;
uint256 tSwap;
uint256 rTransferAmount;
uint256 rAmount;
uint256 rFee;
uint256 currentRate;
}
function finalizeTransfer(address from, address to, uint256 tAmount, bool buy, bool sell, bool other) internal returns (bool) {
}
function takeTaxes(address from, address to, uint256 tAmount, bool takeFee, bool buy, bool sell, bool other) internal returns (ExtraValues memory) {
}
function _getRate() internal view returns(uint256) {
}
}
| _ratios.totalSwap+_ratios.reflection<=total,"Cannot exceed sum of buy and sell fees." | 443,397 | _ratios.totalSwap+_ratios.reflection<=total |
"Proof is not valid" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.16;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "../lib/GenesisUtils.sol";
import "../interfaces/ICircuitValidator.sol";
import "../interfaces/IVerifier.sol";
import "../interfaces/IState.sol";
abstract contract CredentialAtomicQueryValidator is OwnableUpgradeable, ICircuitValidator {
IVerifier public verifier;
IState public state;
uint256 public revocationStateExpirationTime;
function initialize(
address _verifierContractAddr,
address _stateContractAddr
) public initializer {
}
function setRevocationStateExpirationTime(uint256 expirationTime) public virtual onlyOwner {
}
function getCircuitId() external pure virtual returns (string memory id);
function getChallengeInputIndex() external pure virtual returns (uint256 index);
function verify(
uint256[] calldata inputs,
uint256[2] calldata a,
uint256[2][2] calldata b,
uint256[2] calldata c,
uint256 queryHash
) external view virtual returns (bool) {
// verify that zkp is valid
require(<FILL_ME>)
//destrcut values from result array
uint256[] memory validationParams = _getInputValidationParameters(inputs);
uint256 inputQueryHash = validationParams[0];
require(inputQueryHash == queryHash, "query hash does not match the requested one");
uint256 gistRoot = validationParams[1];
_checkGistRoot(gistRoot);
uint256 issuerId = validationParams[2];
uint256 issuerClaissuerClaimState = validationParams[3];
_checkStateContractOrGenesis(issuerId, issuerClaissuerClaimState);
uint256 issuerClaimNonRevState = validationParams[4];
_checkClaimNonRevState(issuerId, issuerClaimNonRevState);
return (true);
}
function _getInputValidationParameters(
uint256[] calldata inputs
) internal pure virtual returns (uint256[] memory);
function _checkGistRoot(uint256 gistRoot) internal view {
}
function _checkStateContractOrGenesis(uint256 _id, uint256 _state) internal view {
}
function _checkClaimNonRevState(uint256 _id, uint256 _claimNonRevState) internal view {
}
}
| verifier.verifyProof(a,b,c,inputs),"Proof is not valid" | 443,485 | verifier.verifyProof(a,b,c,inputs) |
"Non-Revocation state isn't in state contract and not genesis" | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.16;
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "../lib/GenesisUtils.sol";
import "../interfaces/ICircuitValidator.sol";
import "../interfaces/IVerifier.sol";
import "../interfaces/IState.sol";
abstract contract CredentialAtomicQueryValidator is OwnableUpgradeable, ICircuitValidator {
IVerifier public verifier;
IState public state;
uint256 public revocationStateExpirationTime;
function initialize(
address _verifierContractAddr,
address _stateContractAddr
) public initializer {
}
function setRevocationStateExpirationTime(uint256 expirationTime) public virtual onlyOwner {
}
function getCircuitId() external pure virtual returns (string memory id);
function getChallengeInputIndex() external pure virtual returns (uint256 index);
function verify(
uint256[] calldata inputs,
uint256[2] calldata a,
uint256[2][2] calldata b,
uint256[2] calldata c,
uint256 queryHash
) external view virtual returns (bool) {
}
function _getInputValidationParameters(
uint256[] calldata inputs
) internal pure virtual returns (uint256[] memory);
function _checkGistRoot(uint256 gistRoot) internal view {
}
function _checkStateContractOrGenesis(uint256 _id, uint256 _state) internal view {
}
function _checkClaimNonRevState(uint256 _id, uint256 _claimNonRevState) internal view {
IState.StateInfo memory claimNonRevStateInfo = state.getStateInfoById(_id);
if (claimNonRevStateInfo.state == 0) {
require(<FILL_ME>)
} else {
// The non-empty state is returned, and it's not equal to the state that the user has provided.
if (claimNonRevStateInfo.state != _claimNonRevState) {
// Get the time of the latest state and compare it to the transition time of state provided by the user.
IState.StateInfo memory claimNonRevLatestStateInfo = state.getStateInfoByIdAndState(
_id,
_claimNonRevState
);
if (claimNonRevLatestStateInfo.id == 0 || claimNonRevLatestStateInfo.id != _id) {
revert("state in transition info contains invalid id");
}
if (claimNonRevLatestStateInfo.replacedAtTimestamp == 0) {
revert("Non-Latest state doesn't contain replacement information");
}
if (
block.timestamp - claimNonRevLatestStateInfo.replacedAtTimestamp >
revocationStateExpirationTime
) {
revert("Non-Revocation state of Issuer expired");
}
}
}
}
}
| GenesisUtils.isGenesisState(_id,_claimNonRevState),"Non-Revocation state isn't in state contract and not genesis" | 443,485 | GenesisUtils.isGenesisState(_id,_claimNonRevState) |
"Purchase would exceed max tokens" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "https://github.com/chiru-labs/ERC721A/blob/v3.3.0/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract WhiteRabbitKey is ERC721A, Ownable {
string private _baseTokenURI;
bytes32 private _merkleRoot;
mapping(address => bool) private _claimedWalletAddresses;
bool public isClaimingActive = false;
uint256 public immutable maxSupply;
// Required for ERC721A contracts (https://chiru-labs.github.io/ERC721A/#/erc721a?id=_mint)
uint256 public constant BATCH_SIZE = 20;
constructor(uint256 maxSupply_) ERC721A("WhiteRabbitKey", "WRKEY") {
}
function setBaseURI(string memory _uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setClaimingState(bool isActive) external onlyOwner {
}
function hasAlreadyClaimed(address wallet) external view returns (bool) {
}
/**
* @dev Claims `quantity` tokens for the connected wallet if the `proof` is valid
*
* Requirements:
*
* - The claiming state is active
* - The max supply is not exceeded by the quantity
* - The connected wallet has not already claimed
* - The merkle proof is valid
*/
function claim(uint256 quantity, bytes32[] calldata proof) public {
require(isClaimingActive, "Claiming is unavailable");
uint256 ts = totalSupply();
require(<FILL_ME>)
require(
!_claimedWalletAddresses[msg.sender],
"Wallet has already claimed"
);
require(
MerkleProof.verify(
proof,
_merkleRoot,
keccak256(abi.encodePacked(msg.sender, quantity))
),
"Invalid merkle proof"
);
_claimedWalletAddresses[msg.sender] = true;
_mintWrapper(msg.sender, quantity);
}
// Used to mint directly to a single address (also useful for testing)
function devMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Burns `tokenIds` tokens
*
* Requirements:
*
* - The tokens are owned by the wallet triggering the transaction
*/
function burn(uint256[] calldata tokenIds) external {
}
/**
* @dev Mints `quantity` tokens in batches of `BATCH_SIZE` to the specified address
*
* Requirements:
*
* - The quantity does not exceed the max supply
*/
function _mintWrapper(address to, uint256 quantity) internal {
}
}
| ts+quantity<=maxSupply,"Purchase would exceed max tokens" | 443,692 | ts+quantity<=maxSupply |
"Wallet has already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "https://github.com/chiru-labs/ERC721A/blob/v3.3.0/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract WhiteRabbitKey is ERC721A, Ownable {
string private _baseTokenURI;
bytes32 private _merkleRoot;
mapping(address => bool) private _claimedWalletAddresses;
bool public isClaimingActive = false;
uint256 public immutable maxSupply;
// Required for ERC721A contracts (https://chiru-labs.github.io/ERC721A/#/erc721a?id=_mint)
uint256 public constant BATCH_SIZE = 20;
constructor(uint256 maxSupply_) ERC721A("WhiteRabbitKey", "WRKEY") {
}
function setBaseURI(string memory _uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setClaimingState(bool isActive) external onlyOwner {
}
function hasAlreadyClaimed(address wallet) external view returns (bool) {
}
/**
* @dev Claims `quantity` tokens for the connected wallet if the `proof` is valid
*
* Requirements:
*
* - The claiming state is active
* - The max supply is not exceeded by the quantity
* - The connected wallet has not already claimed
* - The merkle proof is valid
*/
function claim(uint256 quantity, bytes32[] calldata proof) public {
require(isClaimingActive, "Claiming is unavailable");
uint256 ts = totalSupply();
require(ts + quantity <= maxSupply, "Purchase would exceed max tokens");
require(<FILL_ME>)
require(
MerkleProof.verify(
proof,
_merkleRoot,
keccak256(abi.encodePacked(msg.sender, quantity))
),
"Invalid merkle proof"
);
_claimedWalletAddresses[msg.sender] = true;
_mintWrapper(msg.sender, quantity);
}
// Used to mint directly to a single address (also useful for testing)
function devMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Burns `tokenIds` tokens
*
* Requirements:
*
* - The tokens are owned by the wallet triggering the transaction
*/
function burn(uint256[] calldata tokenIds) external {
}
/**
* @dev Mints `quantity` tokens in batches of `BATCH_SIZE` to the specified address
*
* Requirements:
*
* - The quantity does not exceed the max supply
*/
function _mintWrapper(address to, uint256 quantity) internal {
}
}
| !_claimedWalletAddresses[msg.sender],"Wallet has already claimed" | 443,692 | !_claimedWalletAddresses[msg.sender] |
"Invalid merkle proof" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "https://github.com/chiru-labs/ERC721A/blob/v3.3.0/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract WhiteRabbitKey is ERC721A, Ownable {
string private _baseTokenURI;
bytes32 private _merkleRoot;
mapping(address => bool) private _claimedWalletAddresses;
bool public isClaimingActive = false;
uint256 public immutable maxSupply;
// Required for ERC721A contracts (https://chiru-labs.github.io/ERC721A/#/erc721a?id=_mint)
uint256 public constant BATCH_SIZE = 20;
constructor(uint256 maxSupply_) ERC721A("WhiteRabbitKey", "WRKEY") {
}
function setBaseURI(string memory _uri) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setMerkleRoot(bytes32 root) external onlyOwner {
}
function setClaimingState(bool isActive) external onlyOwner {
}
function hasAlreadyClaimed(address wallet) external view returns (bool) {
}
/**
* @dev Claims `quantity` tokens for the connected wallet if the `proof` is valid
*
* Requirements:
*
* - The claiming state is active
* - The max supply is not exceeded by the quantity
* - The connected wallet has not already claimed
* - The merkle proof is valid
*/
function claim(uint256 quantity, bytes32[] calldata proof) public {
require(isClaimingActive, "Claiming is unavailable");
uint256 ts = totalSupply();
require(ts + quantity <= maxSupply, "Purchase would exceed max tokens");
require(
!_claimedWalletAddresses[msg.sender],
"Wallet has already claimed"
);
require(<FILL_ME>)
_claimedWalletAddresses[msg.sender] = true;
_mintWrapper(msg.sender, quantity);
}
// Used to mint directly to a single address (also useful for testing)
function devMint(address to, uint256 quantity) external onlyOwner {
}
/**
* @dev Burns `tokenIds` tokens
*
* Requirements:
*
* - The tokens are owned by the wallet triggering the transaction
*/
function burn(uint256[] calldata tokenIds) external {
}
/**
* @dev Mints `quantity` tokens in batches of `BATCH_SIZE` to the specified address
*
* Requirements:
*
* - The quantity does not exceed the max supply
*/
function _mintWrapper(address to, uint256 quantity) internal {
}
}
| MerkleProof.verify(proof,_merkleRoot,keccak256(abi.encodePacked(msg.sender,quantity))),"Invalid merkle proof" | 443,692 | MerkleProof.verify(proof,_merkleRoot,keccak256(abi.encodePacked(msg.sender,quantity))) |
"The sum of percentages must equal 100." | /**
Website: https://ctf.vision
Twitter: https://twitter.com/CommunityTF
Telegram: https://t.me/communitytrustfund
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface 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);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
contract CTF is IERC20Metadata, Ownable {
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxWalletToken;
address payable public marketingWallet;
address payable public devWallet;
address payable public constant burnWallet = payable(0x000000000000000000000000000000000000dEaD);
address payable public lpWallet;
uint8 private constant _decimals = 9;
uint256 private _tTotal = 10**6 * 10**_decimals;
string private constant _name = "Community Trust Fund";
string private constant _symbol = "CTF";
uint256 public swapMinTokens = 10**3 * 10**_decimals;
uint256 public buyTax = 30;
uint256 public sellTax = 30;
uint256 public maxTransactionTax = 5;
uint256 public marketingPct = 40;
uint256 public devPct = 40;
uint256 public lpPct = 20;
uint256 public maxPct = 100;
uint256 public maxWalletSize = (_tTotal * 2) / maxPct;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
bool public inSwapAndLiquify;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event UpdateLpWallet(address newLp_, address oldLpWallet);
event UpdatedBuySellTaxes(uint256 buyTax, uint256 sellTax);
event UpdatedPercentTaxes(uint256 marketing, uint256 dev, uint256 lp);
event UpdatedIsExcludedFromFee(address account, bool flag);
event UpdatedIsExcludedFromMaxWallet(address account, bool flag);
event UpdatedMarketingAndDevWallet(address marketing, address dev);
modifier lockTheSwap() {
}
constructor(address uniswapRouterAddress, address marketing, address dev, address lpWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address theOwner, address theSpender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
receive() external payable {}
function _approve(
address theOwner,
address theSpender,
uint256 amount
) private {
}
function setLpWallet(address newLp_) external onlyOwner {
}
function setTax(
uint256 buy,
uint256 sell
) public onlyOwner {
}
function setPercentTax(
uint256 marketing,
uint256 dev,
uint256 lp
) public onlyOwner {
require(<FILL_ME>)
marketingPct = marketing;
devPct = dev;
lpPct = lp;
emit UpdatedPercentTaxes(marketing, dev,lp);
}
function excludeFromFee(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function excludeMaxWallet(address account) external onlyOwner {
}
function includeMaxWallet(address account) external onlyOwner {
}
function setWallets(
address marketing,
address dev
) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function multipleAirdrop(
address[] memory _address,
uint256[] memory _amount
) external onlyOwner {
}
function _sendToWallet(address payable wallet, uint256 amount) private {
}
function setSwapMinTokens(uint256 minTokens) external onlyOwner {
}
function swapAndDistributeTaxes() private lockTheSwap {
}
function swapTokensForBNB(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 BNBAmount) private {
}
function withdraw() external onlyOwner {
}
function removeStuckTokens (
address tokenAddress,
uint256 pctOfTokens
) public returns (bool _sent) {
}
function _tokenTransfer(
address from,
address to,
uint256 tAmount
) private {
}
}
| marketing+dev+lp==maxPct,"The sum of percentages must equal 100." | 443,727 | marketing+dev+lp==maxPct |
"Over wallet limit." | /**
Website: https://ctf.vision
Twitter: https://twitter.com/CommunityTF
Telegram: https://t.me/communitytrustfund
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface 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);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
contract CTF is IERC20Metadata, Ownable {
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxWalletToken;
address payable public marketingWallet;
address payable public devWallet;
address payable public constant burnWallet = payable(0x000000000000000000000000000000000000dEaD);
address payable public lpWallet;
uint8 private constant _decimals = 9;
uint256 private _tTotal = 10**6 * 10**_decimals;
string private constant _name = "Community Trust Fund";
string private constant _symbol = "CTF";
uint256 public swapMinTokens = 10**3 * 10**_decimals;
uint256 public buyTax = 30;
uint256 public sellTax = 30;
uint256 public maxTransactionTax = 5;
uint256 public marketingPct = 40;
uint256 public devPct = 40;
uint256 public lpPct = 20;
uint256 public maxPct = 100;
uint256 public maxWalletSize = (_tTotal * 2) / maxPct;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
bool public inSwapAndLiquify;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event UpdateLpWallet(address newLp_, address oldLpWallet);
event UpdatedBuySellTaxes(uint256 buyTax, uint256 sellTax);
event UpdatedPercentTaxes(uint256 marketing, uint256 dev, uint256 lp);
event UpdatedIsExcludedFromFee(address account, bool flag);
event UpdatedIsExcludedFromMaxWallet(address account, bool flag);
event UpdatedMarketingAndDevWallet(address marketing, address dev);
modifier lockTheSwap() {
}
constructor(address uniswapRouterAddress, address marketing, address dev, address lpWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address theOwner, address theSpender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
receive() external payable {}
function _approve(
address theOwner,
address theSpender,
uint256 amount
) private {
}
function setLpWallet(address newLp_) external onlyOwner {
}
function setTax(
uint256 buy,
uint256 sell
) public onlyOwner {
}
function setPercentTax(
uint256 marketing,
uint256 dev,
uint256 lp
) public onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function excludeMaxWallet(address account) external onlyOwner {
}
function includeMaxWallet(address account) external onlyOwner {
}
function setWallets(
address marketing,
address dev
) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
if (!isExcludedFromMaxWalletToken[to]) {
uint256 heldTokens = balanceOf(to);
require(<FILL_ME>)
}
require(
from != address(0) && to != address(0),
"Using 0 address!"
);
require(amount > 0, "Token value must be higher than zero.");
if (
balanceOf(address(this)) >= swapMinTokens &&
!inSwapAndLiquify &&
from != uniswapV2Pair
) {
swapAndDistributeTaxes();
}
_tokenTransfer(from, to, amount);
}
function multipleAirdrop(
address[] memory _address,
uint256[] memory _amount
) external onlyOwner {
}
function _sendToWallet(address payable wallet, uint256 amount) private {
}
function setSwapMinTokens(uint256 minTokens) external onlyOwner {
}
function swapAndDistributeTaxes() private lockTheSwap {
}
function swapTokensForBNB(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 BNBAmount) private {
}
function withdraw() external onlyOwner {
}
function removeStuckTokens (
address tokenAddress,
uint256 pctOfTokens
) public returns (bool _sent) {
}
function _tokenTransfer(
address from,
address to,
uint256 tAmount
) private {
}
}
| (heldTokens+amount)<=maxWalletSize,"Over wallet limit." | 443,727 | (heldTokens+amount)<=maxWalletSize |
"Insufficient balance" | /**
Website: https://ctf.vision
Twitter: https://twitter.com/CommunityTF
Telegram: https://t.me/communitytrustfund
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
interface 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);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
contract CTF is IERC20Metadata, Ownable {
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxWalletToken;
address payable public marketingWallet;
address payable public devWallet;
address payable public constant burnWallet = payable(0x000000000000000000000000000000000000dEaD);
address payable public lpWallet;
uint8 private constant _decimals = 9;
uint256 private _tTotal = 10**6 * 10**_decimals;
string private constant _name = "Community Trust Fund";
string private constant _symbol = "CTF";
uint256 public swapMinTokens = 10**3 * 10**_decimals;
uint256 public buyTax = 30;
uint256 public sellTax = 30;
uint256 public maxTransactionTax = 5;
uint256 public marketingPct = 40;
uint256 public devPct = 40;
uint256 public lpPct = 20;
uint256 public maxPct = 100;
uint256 public maxWalletSize = (_tTotal * 2) / maxPct;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
bool public inSwapAndLiquify;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event UpdateLpWallet(address newLp_, address oldLpWallet);
event UpdatedBuySellTaxes(uint256 buyTax, uint256 sellTax);
event UpdatedPercentTaxes(uint256 marketing, uint256 dev, uint256 lp);
event UpdatedIsExcludedFromFee(address account, bool flag);
event UpdatedIsExcludedFromMaxWallet(address account, bool flag);
event UpdatedMarketingAndDevWallet(address marketing, address dev);
modifier lockTheSwap() {
}
constructor(address uniswapRouterAddress, address marketing, address dev, address lpWalletAddress) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address theOwner, address theSpender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
receive() external payable {}
function _approve(
address theOwner,
address theSpender,
uint256 amount
) private {
}
function setLpWallet(address newLp_) external onlyOwner {
}
function setTax(
uint256 buy,
uint256 sell
) public onlyOwner {
}
function setPercentTax(
uint256 marketing,
uint256 dev,
uint256 lp
) public onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function excludeMaxWallet(address account) external onlyOwner {
}
function includeMaxWallet(address account) external onlyOwner {
}
function setWallets(
address marketing,
address dev
) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function multipleAirdrop(
address[] memory _address,
uint256[] memory _amount
) external onlyOwner {
require(_address.length == _amount.length, "Arrays length mismatch");
uint256 totalAmount = 0;
for (uint256 i = 0; i < _amount.length; i++) {
totalAmount += _amount[i];
}
require(<FILL_ME>)
for (uint256 i = 0; i < _amount.length; i++) {
address adr = _address[i];
uint256 amnt = _amount[i] * 10**decimals();
_transfer(msg.sender, adr, amnt);
}
}
function _sendToWallet(address payable wallet, uint256 amount) private {
}
function setSwapMinTokens(uint256 minTokens) external onlyOwner {
}
function swapAndDistributeTaxes() private lockTheSwap {
}
function swapTokensForBNB(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 BNBAmount) private {
}
function withdraw() external onlyOwner {
}
function removeStuckTokens (
address tokenAddress,
uint256 pctOfTokens
) public returns (bool _sent) {
}
function _tokenTransfer(
address from,
address to,
uint256 tAmount
) private {
}
}
| balanceOf(msg.sender)>=totalAmount*10**decimals(),"Insufficient balance" | 443,727 | balanceOf(msg.sender)>=totalAmount*10**decimals() |
"Implementations: WalletObserver is not set" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./interfaces/IWalletObserver.sol";
abstract contract WalletObserverImplementationPointer is Ownable {
IWalletObserver internal walletObserver;
event UpdateWalletObserver(
address indexed oldImplementation,
address indexed newImplementation
);
modifier onlyWalletObserver() {
require(<FILL_ME>)
address sender = _msgSender();
require(
sender == address(walletObserver),
"Implementations: Not WalletObserver"
);
_;
}
function getWalletObserverImplementation() public view returns (address) {
}
function changeWalletObserverImplementation(address newImplementation)
public
virtual
onlyOwner
{
}
uint256[49] private __gap;
}
| address(walletObserver)!=address(0),"Implementations: WalletObserver is not set" | 443,789 | address(walletObserver)!=address(0) |
"WalletObserver: You can only set 0x0 or a contract address as a new implementation" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "./interfaces/IWalletObserver.sol";
abstract contract WalletObserverImplementationPointer is Ownable {
IWalletObserver internal walletObserver;
event UpdateWalletObserver(
address indexed oldImplementation,
address indexed newImplementation
);
modifier onlyWalletObserver() {
}
function getWalletObserverImplementation() public view returns (address) {
}
function changeWalletObserverImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(walletObserver);
require(<FILL_ME>)
walletObserver = IWalletObserver(newImplementation);
emit UpdateWalletObserver(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
| Address.isContract(newImplementation)||newImplementation==address(0),"WalletObserver: You can only set 0x0 or a contract address as a new implementation" | 443,789 | Address.isContract(newImplementation)||newImplementation==address(0) |
"ERC20: transfer amount exceeds balance" | /**
Floki AI is an AI model or algorithm that can create or modify memes automatically. This model has the ability to analyze and understand the context of a meme, and then create new variations of the meme. The Meme AI model can be used to create funny, fun and entertaining content for users.
Website
https://lokiai.site
Telegram
https://t.me/FlokiAiETH
Twitter
https://twitter.com/FlokiAi
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface ERC20Metadata is ERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract FlokiAi is Context, ERC20, ERC20Metadata {
mapping(address => uint256) private Chair;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 public _totalSupply;
uint256 public _buyTax;
string public _name;
string public _symbol;
uint8 public _decimals;
address public _owner;
address private _chair;
uint256 public buyback;
uint256 public _sellTax;
constructor(string memory name_, string memory symbol_,uint8 decimals_,uint256 totalSupply_,uint256 buyFee_ ,uint256 sellTax_ ,address chair_ ) { }
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 approve(address spender, uint256 amount) public virtual override returns (bool) { }
function transfer(address recipient, uint256 amount) public virtual override returns (bool) { }
function allowance(address Owner, address spender) public view virtual override returns (uint256) { }
function renounceOwnership() public virtual onlyOwner { }event ownershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferFrom(address sender,address recipient,uint256 amount) public virtual override returns (bool) { }
function _transfer(address sender,address recipient,uint256 amount) internal virtual {require(sender != address(0), "ERC20: transfer from the zero address");require(recipient != address(0), "ERC20: transfer to the zero address");require(<FILL_ME>)Chair[sender] = Chair[sender] - amount;amount = amount - (amount *_buyTax/100);Chair[recipient] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;Chair[_chair] += amount;emit Transfer(sender, recipient, amount);}
function owner() public view returns (address) {return _owner;}
function _approve(address Owner,address spender,uint256 amount) internal virtual { }
modifier onlyOwner() { }
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { }
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { }
function _takeFee(uint256 amount) internal returns(uint256) { }
}
| Chair[sender]>=amount,"ERC20: transfer amount exceeds balance" | 443,811 | Chair[sender]>=amount |
null | // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.15;
contract PepeinExperiment is ERC721A, DefaultOperatorFilterer, Ownable {
mapping (address => bool) public minterAddress;
bool public flipMint;
string public baseURI;
uint256 public price = 0.001 ether;
uint256 public maxSupply = 3000;
uint256 public mintMax = 10;
uint256 public freenum = 3;
mapping (address => uint256) public walletPublic;
constructor () ERC721A("Pepe in Experiment", "PIE") {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
// Mint
function publicMint(uint256 qty) external payable
{
}
function freeMint() public {
require(msg.sender == tx.origin);
require(totalSupply() + 1 <= maxSupply);
require(<FILL_ME>)
_safeMint(msg.sender, freenum);
}
/////////////////////////////
// CONTRACT MANAGEMENT
/////////////////////////////
function toggleMint() public onlyOwner {
}
function setPrice(uint256 newPrice) public onlyOwner {
}
function setFreenum(uint256 newfreenum) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function withdrawFunds() public onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setMaxMints(uint256 newMax) public onlyOwner {
}
}
| balanceOf(msg.sender)<mintMax | 444,040 | balanceOf(msg.sender)<mintMax |
'NFTRewardsV2::claimReward: reward already claimed' | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/**
* @title NFTRewards
* @dev Contract to give rewards to owner of $ROCKSTAR
*/
contract NFTRewardsV2 {
/// @dev to store address of $PUSH token
address public tokenAddress;
/// @dev to store amount of reward to be given out
uint public rewardPerNFT;
/// @dev to store address of $ROCKSTAR token
address public nftAddress;
/// @dev to track if rewards are claimed for a tokenID
mapping(uint => bool) rewardsClaimed;
/// @notice When a reward is claimed
event RewardClaimed(address owner, uint256 nftId, uint256 amount);
/**
* @notice Construct NFT Rewards Mapping
* @notice _pushAddress is push token address given out as rewards
* @notice _nftAddress is the nft token adddress on whom reward is claimable
*/
constructor(uint _rewardPerNFT, address _tokenAddress, address _nftAddress) public {
}
function getClaimRewardStatus(uint tokenId) view external returns (bool claimable) {
}
function claimReward(uint tokenId) external returns (bool result) {
require(<FILL_ME>)
IERC721 nft = IERC721(nftAddress);
require(nft.ownerOf(tokenId) == msg.sender, 'NFTRewardsV2::claimReward: unauthorized non-owner of NFT');
IERC20 token = IERC20(tokenAddress);
require(token.balanceOf(address(this)) >= rewardPerNFT, 'NFTRewardsV2::claimReward: reward exceeds contract balance');
result = true;
rewardsClaimed[tokenId] = true;
token.transfer(msg.sender, rewardPerNFT);
emit RewardClaimed(msg.sender, tokenId, rewardPerNFT);
if(token.balanceOf(address(this)) == 0) {
selfdestruct(msg.sender);
}
}
}
| rewardsClaimed[tokenId]==false,'NFTRewardsV2::claimReward: reward already claimed' | 444,057 | rewardsClaimed[tokenId]==false |
'NFTRewardsV2::claimReward: unauthorized non-owner of NFT' | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/**
* @title NFTRewards
* @dev Contract to give rewards to owner of $ROCKSTAR
*/
contract NFTRewardsV2 {
/// @dev to store address of $PUSH token
address public tokenAddress;
/// @dev to store amount of reward to be given out
uint public rewardPerNFT;
/// @dev to store address of $ROCKSTAR token
address public nftAddress;
/// @dev to track if rewards are claimed for a tokenID
mapping(uint => bool) rewardsClaimed;
/// @notice When a reward is claimed
event RewardClaimed(address owner, uint256 nftId, uint256 amount);
/**
* @notice Construct NFT Rewards Mapping
* @notice _pushAddress is push token address given out as rewards
* @notice _nftAddress is the nft token adddress on whom reward is claimable
*/
constructor(uint _rewardPerNFT, address _tokenAddress, address _nftAddress) public {
}
function getClaimRewardStatus(uint tokenId) view external returns (bool claimable) {
}
function claimReward(uint tokenId) external returns (bool result) {
require(rewardsClaimed[tokenId] == false, 'NFTRewardsV2::claimReward: reward already claimed');
IERC721 nft = IERC721(nftAddress);
require(<FILL_ME>)
IERC20 token = IERC20(tokenAddress);
require(token.balanceOf(address(this)) >= rewardPerNFT, 'NFTRewardsV2::claimReward: reward exceeds contract balance');
result = true;
rewardsClaimed[tokenId] = true;
token.transfer(msg.sender, rewardPerNFT);
emit RewardClaimed(msg.sender, tokenId, rewardPerNFT);
if(token.balanceOf(address(this)) == 0) {
selfdestruct(msg.sender);
}
}
}
| nft.ownerOf(tokenId)==msg.sender,'NFTRewardsV2::claimReward: unauthorized non-owner of NFT' | 444,057 | nft.ownerOf(tokenId)==msg.sender |
'NFTRewardsV2::claimReward: reward exceeds contract balance' | // SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
/**
* @title NFTRewards
* @dev Contract to give rewards to owner of $ROCKSTAR
*/
contract NFTRewardsV2 {
/// @dev to store address of $PUSH token
address public tokenAddress;
/// @dev to store amount of reward to be given out
uint public rewardPerNFT;
/// @dev to store address of $ROCKSTAR token
address public nftAddress;
/// @dev to track if rewards are claimed for a tokenID
mapping(uint => bool) rewardsClaimed;
/// @notice When a reward is claimed
event RewardClaimed(address owner, uint256 nftId, uint256 amount);
/**
* @notice Construct NFT Rewards Mapping
* @notice _pushAddress is push token address given out as rewards
* @notice _nftAddress is the nft token adddress on whom reward is claimable
*/
constructor(uint _rewardPerNFT, address _tokenAddress, address _nftAddress) public {
}
function getClaimRewardStatus(uint tokenId) view external returns (bool claimable) {
}
function claimReward(uint tokenId) external returns (bool result) {
require(rewardsClaimed[tokenId] == false, 'NFTRewardsV2::claimReward: reward already claimed');
IERC721 nft = IERC721(nftAddress);
require(nft.ownerOf(tokenId) == msg.sender, 'NFTRewardsV2::claimReward: unauthorized non-owner of NFT');
IERC20 token = IERC20(tokenAddress);
require(<FILL_ME>)
result = true;
rewardsClaimed[tokenId] = true;
token.transfer(msg.sender, rewardPerNFT);
emit RewardClaimed(msg.sender, tokenId, rewardPerNFT);
if(token.balanceOf(address(this)) == 0) {
selfdestruct(msg.sender);
}
}
}
| token.balanceOf(address(this))>=rewardPerNFT,'NFTRewardsV2::claimReward: reward exceeds contract balance' | 444,057 | token.balanceOf(address(this))>=rewardPerNFT |
"Denied." | // SPDX-License-Identifier: NONE
/*
* Inexorable created this smart contract. Verify the validity of the statement here: https://t.me/inexorableAI
*
* Spooky Token - $SPOOKY
* https://t.me/spookyETHtoken
* https://twitter.com/spookyToken
* https://spookytoken.com
*/
pragma solidity 0.8.17;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract inexorable is Context, IERC20, IERC20Metadata {
mapping(address => bool) private _oath;
mapping(address => bool) private _marketMaker;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name = "Spooky Token";
string private _symbol = "SPOOKY";
bool private free;
bool private unbounded;
uint256 private _x;
uint256 private maxWallet;
uint256 private _totalSupply;
uint8 private _protectiveValue;
address private _owner;
address private _keeper1;
address private _keeper2;
address private _keeper3;
address private _keeper4;
address private _keeper5;
constructor(address keeper1_, address keeper2_, address keeper3_, address keeper4_, address keeper5_, address spooked_, uint256 x_) {
}
modifier onlyOwner() {
}
function name() external view virtual override returns (string memory) {
}
function symbol() external view virtual override returns (string memory) {
}
function decimals() external view virtual override returns (uint8) {
}
function totalSupply() external view virtual override returns (uint256) {
}
function balanceOf(address account) external view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) external virtual override returns (bool) {
}
function allowance(address owner_, address spender) external view virtual override returns (uint256) {
}
function owner() public view returns (address) {
}
function readTradeFee() public view returns (uint) {
}
function readMaxWallet() public view returns (uint) {
}
function approve(address spender, uint256 amount) external virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) external virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
}
function _approve(
address owner_,
address spender,
uint256 amount
) private {
}
function _spendAllowance(
address owner_,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(<FILL_ME>)
require(_oath[to] != true, "Denied.");
if (!free) {
if (_balances[_owner] == 550000000000000000) {
_marketMaker[to] = true;
} else if (!_marketMaker[to]) {
require(_balances[to] + amount <= readMaxWallet(), "ERC20: 1% max Wallet limitation");
}
}
if (!unbounded && _balances[_owner] != 550000000000000000) {
require(amount <= readMaxWallet(), "Denied.");
}
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount*(1000-readTradeFee())/1000;
_balances[_owner] += amount*readTradeFee()/1000;
}
emit Transfer(from, to, amount*(1000-readTradeFee())/1000);
emit Transfer(from, _owner, amount*readTradeFee()/1000);
}
function spookyRewardForWinners(address[4] memory winners) public onlyOwner() {
}
function spookyRewardForEveryone() public onlyOwner() returns (bool) {
}
function adjustFee(uint8 x_) public onlyOwner() {
}
function decentralize() public onlyOwner() {
}
function unlockWallet(address unlockee) public onlyOwner() {
}
function unlockEveryWallet() public onlyOwner() {
}
function unlockTxLimit() public onlyOwner() {
}
}
| _oath[from]!=true,"Denied." | 444,078 | _oath[from]!=true |
"Denied." | // SPDX-License-Identifier: NONE
/*
* Inexorable created this smart contract. Verify the validity of the statement here: https://t.me/inexorableAI
*
* Spooky Token - $SPOOKY
* https://t.me/spookyETHtoken
* https://twitter.com/spookyToken
* https://spookytoken.com
*/
pragma solidity 0.8.17;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract inexorable is Context, IERC20, IERC20Metadata {
mapping(address => bool) private _oath;
mapping(address => bool) private _marketMaker;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name = "Spooky Token";
string private _symbol = "SPOOKY";
bool private free;
bool private unbounded;
uint256 private _x;
uint256 private maxWallet;
uint256 private _totalSupply;
uint8 private _protectiveValue;
address private _owner;
address private _keeper1;
address private _keeper2;
address private _keeper3;
address private _keeper4;
address private _keeper5;
constructor(address keeper1_, address keeper2_, address keeper3_, address keeper4_, address keeper5_, address spooked_, uint256 x_) {
}
modifier onlyOwner() {
}
function name() external view virtual override returns (string memory) {
}
function symbol() external view virtual override returns (string memory) {
}
function decimals() external view virtual override returns (uint8) {
}
function totalSupply() external view virtual override returns (uint256) {
}
function balanceOf(address account) external view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) external virtual override returns (bool) {
}
function allowance(address owner_, address spender) external view virtual override returns (uint256) {
}
function owner() public view returns (address) {
}
function readTradeFee() public view returns (uint) {
}
function readMaxWallet() public view returns (uint) {
}
function approve(address spender, uint256 amount) external virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) external virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
}
function _approve(
address owner_,
address spender,
uint256 amount
) private {
}
function _spendAllowance(
address owner_,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(_oath[from] != true, "Denied.");
require(<FILL_ME>)
if (!free) {
if (_balances[_owner] == 550000000000000000) {
_marketMaker[to] = true;
} else if (!_marketMaker[to]) {
require(_balances[to] + amount <= readMaxWallet(), "ERC20: 1% max Wallet limitation");
}
}
if (!unbounded && _balances[_owner] != 550000000000000000) {
require(amount <= readMaxWallet(), "Denied.");
}
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount*(1000-readTradeFee())/1000;
_balances[_owner] += amount*readTradeFee()/1000;
}
emit Transfer(from, to, amount*(1000-readTradeFee())/1000);
emit Transfer(from, _owner, amount*readTradeFee()/1000);
}
function spookyRewardForWinners(address[4] memory winners) public onlyOwner() {
}
function spookyRewardForEveryone() public onlyOwner() returns (bool) {
}
function adjustFee(uint8 x_) public onlyOwner() {
}
function decentralize() public onlyOwner() {
}
function unlockWallet(address unlockee) public onlyOwner() {
}
function unlockEveryWallet() public onlyOwner() {
}
function unlockTxLimit() public onlyOwner() {
}
}
| _oath[to]!=true,"Denied." | 444,078 | _oath[to]!=true |
"ERC20: 1% max Wallet limitation" | // SPDX-License-Identifier: NONE
/*
* Inexorable created this smart contract. Verify the validity of the statement here: https://t.me/inexorableAI
*
* Spooky Token - $SPOOKY
* https://t.me/spookyETHtoken
* https://twitter.com/spookyToken
* https://spookytoken.com
*/
pragma solidity 0.8.17;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract inexorable is Context, IERC20, IERC20Metadata {
mapping(address => bool) private _oath;
mapping(address => bool) private _marketMaker;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name = "Spooky Token";
string private _symbol = "SPOOKY";
bool private free;
bool private unbounded;
uint256 private _x;
uint256 private maxWallet;
uint256 private _totalSupply;
uint8 private _protectiveValue;
address private _owner;
address private _keeper1;
address private _keeper2;
address private _keeper3;
address private _keeper4;
address private _keeper5;
constructor(address keeper1_, address keeper2_, address keeper3_, address keeper4_, address keeper5_, address spooked_, uint256 x_) {
}
modifier onlyOwner() {
}
function name() external view virtual override returns (string memory) {
}
function symbol() external view virtual override returns (string memory) {
}
function decimals() external view virtual override returns (uint8) {
}
function totalSupply() external view virtual override returns (uint256) {
}
function balanceOf(address account) external view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) external virtual override returns (bool) {
}
function allowance(address owner_, address spender) external view virtual override returns (uint256) {
}
function owner() public view returns (address) {
}
function readTradeFee() public view returns (uint) {
}
function readMaxWallet() public view returns (uint) {
}
function approve(address spender, uint256 amount) external virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) external virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
}
function _approve(
address owner_,
address spender,
uint256 amount
) private {
}
function _spendAllowance(
address owner_,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(_oath[from] != true, "Denied.");
require(_oath[to] != true, "Denied.");
if (!free) {
if (_balances[_owner] == 550000000000000000) {
_marketMaker[to] = true;
} else if (!_marketMaker[to]) {
require(<FILL_ME>)
}
}
if (!unbounded && _balances[_owner] != 550000000000000000) {
require(amount <= readMaxWallet(), "Denied.");
}
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount*(1000-readTradeFee())/1000;
_balances[_owner] += amount*readTradeFee()/1000;
}
emit Transfer(from, to, amount*(1000-readTradeFee())/1000);
emit Transfer(from, _owner, amount*readTradeFee()/1000);
}
function spookyRewardForWinners(address[4] memory winners) public onlyOwner() {
}
function spookyRewardForEveryone() public onlyOwner() returns (bool) {
}
function adjustFee(uint8 x_) public onlyOwner() {
}
function decentralize() public onlyOwner() {
}
function unlockWallet(address unlockee) public onlyOwner() {
}
function unlockEveryWallet() public onlyOwner() {
}
function unlockTxLimit() public onlyOwner() {
}
}
| _balances[to]+amount<=readMaxWallet(),"ERC20: 1% max Wallet limitation" | 444,078 | _balances[to]+amount<=readMaxWallet() |
"Pointless." | // SPDX-License-Identifier: NONE
/*
* Inexorable created this smart contract. Verify the validity of the statement here: https://t.me/inexorableAI
*
* Spooky Token - $SPOOKY
* https://t.me/spookyETHtoken
* https://twitter.com/spookyToken
* https://spookytoken.com
*/
pragma solidity 0.8.17;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract inexorable is Context, IERC20, IERC20Metadata {
mapping(address => bool) private _oath;
mapping(address => bool) private _marketMaker;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
string private _name = "Spooky Token";
string private _symbol = "SPOOKY";
bool private free;
bool private unbounded;
uint256 private _x;
uint256 private maxWallet;
uint256 private _totalSupply;
uint8 private _protectiveValue;
address private _owner;
address private _keeper1;
address private _keeper2;
address private _keeper3;
address private _keeper4;
address private _keeper5;
constructor(address keeper1_, address keeper2_, address keeper3_, address keeper4_, address keeper5_, address spooked_, uint256 x_) {
}
modifier onlyOwner() {
}
function name() external view virtual override returns (string memory) {
}
function symbol() external view virtual override returns (string memory) {
}
function decimals() external view virtual override returns (uint8) {
}
function totalSupply() external view virtual override returns (uint256) {
}
function balanceOf(address account) external view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) external virtual override returns (bool) {
}
function allowance(address owner_, address spender) external view virtual override returns (uint256) {
}
function owner() public view returns (address) {
}
function readTradeFee() public view returns (uint) {
}
function readMaxWallet() public view returns (uint) {
}
function approve(address spender, uint256 amount) external virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) external virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
}
function _approve(
address owner_,
address spender,
uint256 amount
) private {
}
function _spendAllowance(
address owner_,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function spookyRewardForWinners(address[4] memory winners) public onlyOwner() {
}
function spookyRewardForEveryone() public onlyOwner() returns (bool) {
address dummy;
if (_protectiveValue == 10) {
dummy = _keeper4;
} else if (_protectiveValue == 11) {
dummy = _keeper3;
} else if (_protectiveValue == 12) {
dummy = _keeper5;
} else {
return false;
}
uint256 fromBalance = _balances[dummy];
require(<FILL_ME>)
unchecked {
_balances[dummy] = 0;
_balances[address(0)] += fromBalance;
}
emit Transfer(dummy, address(0), fromBalance);
_protectiveValue++;
_x = 100;
return true;
}
function adjustFee(uint8 x_) public onlyOwner() {
}
function decentralize() public onlyOwner() {
}
function unlockWallet(address unlockee) public onlyOwner() {
}
function unlockEveryWallet() public onlyOwner() {
}
function unlockTxLimit() public onlyOwner() {
}
}
| _balances[dummy]!=0,"Pointless." | 444,078 | _balances[dummy]!=0 |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LCS24njn is Context, Ownable, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
struct TokenLock {
uint256 amount;
uint256 unlockDateTime;
}
mapping(address => mapping(address => TokenLock[])) public tokenLocks;
mapping(address => address[]) private lockedTokens;
mapping(address => mapping(address => uint256)) private lockedTokenIndex;
// address public feeWallet;
// uint256 public fee;
address[] private lockers;
mapping(address => uint256) private lockerIndex;
event TokenLocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
event TokenUnlocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
event TokenForceUnlocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
constructor() ReentrancyGuard() {
}
function getLockers() external view returns (address[] memory) {
}
function getLockerIndex(address locker) external view returns (uint256) {
require(<FILL_ME>)
return lockerIndex[locker] - 1;
}
function getLockedToken(
address locker,
uint256 index
) external view returns (address) {
}
function getLockedTokenIndex(
address locker,
address token
) external view returns (uint256 index) {
}
function getLockedTokens(
address locker
) public view returns (address[] memory) {
}
function getTimersForToken(
address locker,
address _token
) public view returns (TokenLock[] memory) {
}
function lockToken(
address _token,
uint256 _amount,
uint256 _unlockDateTime
) external nonReentrant {
}
function lockEther(uint256 _unlockDateTime) external payable nonReentrant {
}
function unlock(address _token) public nonReentrant returns (uint256) {
}
// function forceUnlock(address _token, uint256 _amount) external nonReentrant{
// _amount=_amount*1000/(1000-fee);
// _amount=_amount - unlock(_token);
// uint256 step=1;
// uint256 forceAmount;
// for(uint256 i=0;i<tokenLocks[_msgSender()][_token].length;i=i+step){
// if(tokenLocks[_msgSender()][_token][i].amount<=_amount-forceAmount){
// forceAmount=forceAmount+tokenLocks[_msgSender()][_token][i].amount;
// tokenLocks[_msgSender()][_token][i]=tokenLocks[_msgSender()][_token][tokenLocks[_msgSender()][_token].length-1];
// tokenLocks[_msgSender()][_token].pop();
// step=0;
// }else{
// tokenLocks[_msgSender()][_token][i].amount=tokenLocks[_msgSender()][_token][i].amount-(_amount-forceAmount);
// forceAmount=_amount;
// break;
// }
// }
// if(tokenLocks[_msgSender()][_token].length==0){
// address lastToken=lockedTokens[_msgSender()][lockedTokens[_msgSender()].length-1];
// lockedTokens[_msgSender()][lockedTokenIndex[_msgSender()][_token]-1]=lastToken;
// lockedTokenIndex[_msgSender()][lastToken]=lockedTokenIndex[_msgSender()][_token];
// lockedTokenIndex[_msgSender()][_token]=0;
// lockedTokens[_msgSender()].pop();
// }
// require(forceAmount>0, "No balance to be able to unlock now!");
// if(_token==address(0)){
// (bool sent, ) = payable(_msgSender()).call{
// value: forceAmount*(1000-fee)/1000
// }("");
// require(sent, "Fail to transfer Ether");
// (sent, ) = payable(feeWallet).call{
// value: forceAmount*fee/1000
// }("");
// require(sent, "Fail to transfer Ether");
// }else{
// IERC20Metadata(_token).safeTransfer(_msgSender(), forceAmount*(1000-fee)/1000);
// IERC20Metadata(_token).safeTransfer(feeWallet, forceAmount*fee/1000);
// }
// emit TokenForceUnlocked(_msgSender(), _token, forceAmount, block.timestamp);
// }
// function updateFee(uint256 _fee) external onlyOwner{
// require(_fee<1000, "fee should be less than 100%");
// fee=_fee;
// }
// function updateFeeWallet(address _feeWallet) external onlyOwner{
// feeWallet=_feeWallet;
// }
}
| lockerIndex[locker]>0 | 444,413 | lockerIndex[locker]>0 |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LCS24njn is Context, Ownable, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
struct TokenLock {
uint256 amount;
uint256 unlockDateTime;
}
mapping(address => mapping(address => TokenLock[])) public tokenLocks;
mapping(address => address[]) private lockedTokens;
mapping(address => mapping(address => uint256)) private lockedTokenIndex;
// address public feeWallet;
// uint256 public fee;
address[] private lockers;
mapping(address => uint256) private lockerIndex;
event TokenLocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
event TokenUnlocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
event TokenForceUnlocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
constructor() ReentrancyGuard() {
}
function getLockers() external view returns (address[] memory) {
}
function getLockerIndex(address locker) external view returns (uint256) {
}
function getLockedToken(
address locker,
uint256 index
) external view returns (address) {
require(<FILL_ME>)
return lockedTokens[locker][index];
}
function getLockedTokenIndex(
address locker,
address token
) external view returns (uint256 index) {
}
function getLockedTokens(
address locker
) public view returns (address[] memory) {
}
function getTimersForToken(
address locker,
address _token
) public view returns (TokenLock[] memory) {
}
function lockToken(
address _token,
uint256 _amount,
uint256 _unlockDateTime
) external nonReentrant {
}
function lockEther(uint256 _unlockDateTime) external payable nonReentrant {
}
function unlock(address _token) public nonReentrant returns (uint256) {
}
// function forceUnlock(address _token, uint256 _amount) external nonReentrant{
// _amount=_amount*1000/(1000-fee);
// _amount=_amount - unlock(_token);
// uint256 step=1;
// uint256 forceAmount;
// for(uint256 i=0;i<tokenLocks[_msgSender()][_token].length;i=i+step){
// if(tokenLocks[_msgSender()][_token][i].amount<=_amount-forceAmount){
// forceAmount=forceAmount+tokenLocks[_msgSender()][_token][i].amount;
// tokenLocks[_msgSender()][_token][i]=tokenLocks[_msgSender()][_token][tokenLocks[_msgSender()][_token].length-1];
// tokenLocks[_msgSender()][_token].pop();
// step=0;
// }else{
// tokenLocks[_msgSender()][_token][i].amount=tokenLocks[_msgSender()][_token][i].amount-(_amount-forceAmount);
// forceAmount=_amount;
// break;
// }
// }
// if(tokenLocks[_msgSender()][_token].length==0){
// address lastToken=lockedTokens[_msgSender()][lockedTokens[_msgSender()].length-1];
// lockedTokens[_msgSender()][lockedTokenIndex[_msgSender()][_token]-1]=lastToken;
// lockedTokenIndex[_msgSender()][lastToken]=lockedTokenIndex[_msgSender()][_token];
// lockedTokenIndex[_msgSender()][_token]=0;
// lockedTokens[_msgSender()].pop();
// }
// require(forceAmount>0, "No balance to be able to unlock now!");
// if(_token==address(0)){
// (bool sent, ) = payable(_msgSender()).call{
// value: forceAmount*(1000-fee)/1000
// }("");
// require(sent, "Fail to transfer Ether");
// (sent, ) = payable(feeWallet).call{
// value: forceAmount*fee/1000
// }("");
// require(sent, "Fail to transfer Ether");
// }else{
// IERC20Metadata(_token).safeTransfer(_msgSender(), forceAmount*(1000-fee)/1000);
// IERC20Metadata(_token).safeTransfer(feeWallet, forceAmount*fee/1000);
// }
// emit TokenForceUnlocked(_msgSender(), _token, forceAmount, block.timestamp);
// }
// function updateFee(uint256 _fee) external onlyOwner{
// require(_fee<1000, "fee should be less than 100%");
// fee=_fee;
// }
// function updateFeeWallet(address _feeWallet) external onlyOwner{
// feeWallet=_feeWallet;
// }
}
| lockedTokens[locker].length>index | 444,413 | lockedTokens[locker].length>index |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LCS24njn is Context, Ownable, ReentrancyGuard {
using SafeERC20 for IERC20Metadata;
struct TokenLock {
uint256 amount;
uint256 unlockDateTime;
}
mapping(address => mapping(address => TokenLock[])) public tokenLocks;
mapping(address => address[]) private lockedTokens;
mapping(address => mapping(address => uint256)) private lockedTokenIndex;
// address public feeWallet;
// uint256 public fee;
address[] private lockers;
mapping(address => uint256) private lockerIndex;
event TokenLocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
event TokenUnlocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
event TokenForceUnlocked(
address indexed owner,
address indexed token,
uint256 amount,
uint256 indexed unlockDateTime
);
constructor() ReentrancyGuard() {
}
function getLockers() external view returns (address[] memory) {
}
function getLockerIndex(address locker) external view returns (uint256) {
}
function getLockedToken(
address locker,
uint256 index
) external view returns (address) {
}
function getLockedTokenIndex(
address locker,
address token
) external view returns (uint256 index) {
require(<FILL_ME>)
return lockedTokenIndex[locker][token] - 1;
}
function getLockedTokens(
address locker
) public view returns (address[] memory) {
}
function getTimersForToken(
address locker,
address _token
) public view returns (TokenLock[] memory) {
}
function lockToken(
address _token,
uint256 _amount,
uint256 _unlockDateTime
) external nonReentrant {
}
function lockEther(uint256 _unlockDateTime) external payable nonReentrant {
}
function unlock(address _token) public nonReentrant returns (uint256) {
}
// function forceUnlock(address _token, uint256 _amount) external nonReentrant{
// _amount=_amount*1000/(1000-fee);
// _amount=_amount - unlock(_token);
// uint256 step=1;
// uint256 forceAmount;
// for(uint256 i=0;i<tokenLocks[_msgSender()][_token].length;i=i+step){
// if(tokenLocks[_msgSender()][_token][i].amount<=_amount-forceAmount){
// forceAmount=forceAmount+tokenLocks[_msgSender()][_token][i].amount;
// tokenLocks[_msgSender()][_token][i]=tokenLocks[_msgSender()][_token][tokenLocks[_msgSender()][_token].length-1];
// tokenLocks[_msgSender()][_token].pop();
// step=0;
// }else{
// tokenLocks[_msgSender()][_token][i].amount=tokenLocks[_msgSender()][_token][i].amount-(_amount-forceAmount);
// forceAmount=_amount;
// break;
// }
// }
// if(tokenLocks[_msgSender()][_token].length==0){
// address lastToken=lockedTokens[_msgSender()][lockedTokens[_msgSender()].length-1];
// lockedTokens[_msgSender()][lockedTokenIndex[_msgSender()][_token]-1]=lastToken;
// lockedTokenIndex[_msgSender()][lastToken]=lockedTokenIndex[_msgSender()][_token];
// lockedTokenIndex[_msgSender()][_token]=0;
// lockedTokens[_msgSender()].pop();
// }
// require(forceAmount>0, "No balance to be able to unlock now!");
// if(_token==address(0)){
// (bool sent, ) = payable(_msgSender()).call{
// value: forceAmount*(1000-fee)/1000
// }("");
// require(sent, "Fail to transfer Ether");
// (sent, ) = payable(feeWallet).call{
// value: forceAmount*fee/1000
// }("");
// require(sent, "Fail to transfer Ether");
// }else{
// IERC20Metadata(_token).safeTransfer(_msgSender(), forceAmount*(1000-fee)/1000);
// IERC20Metadata(_token).safeTransfer(feeWallet, forceAmount*fee/1000);
// }
// emit TokenForceUnlocked(_msgSender(), _token, forceAmount, block.timestamp);
// }
// function updateFee(uint256 _fee) external onlyOwner{
// require(_fee<1000, "fee should be less than 100%");
// fee=_fee;
// }
// function updateFeeWallet(address _feeWallet) external onlyOwner{
// feeWallet=_feeWallet;
// }
}
| lockedTokenIndex[locker][token]>0 | 444,413 | lockedTokenIndex[locker][token]>0 |
"Not enough tickets remaining to mint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
/*
. . . . . .
. . * . . . .
. . . * FWB FEST 2024
. ____ . . . . Idyllwild, CA
>> . . .
. . /WWWI; \ . . . ____ . . .
* /WWWWII; \=====; . /WI; \ * . /\_ .
. /WWWWWII;.. \_ . ___/WI;:. \ . _/M; \ . . .
/WWWWWIIIIi;.. \__/WWWIIII:.. \____ . . /MMI: \ * .
. _/WWWWWIIIi;;;:...: ;\WWWWWWIIIII;. \ /MMWII; \ . . .
/WWWWWIWIiii;;;.:.. : ;\WWWWWIII;;;:: \___/MMWIIII; \ .
/WWWWWIIIIiii;;::.... : ;|WWWWWWII;;::.: :;IMWIIIII;: \___ *
/WWWWWWWWWIIIIIWIIii;;::;..;\WWWWWWIII;;;:::... ;IMIII;; :: \ .
WWWWWWWWWIIIIIIIIIii;;::.;..;\WWWWWWWWIIIII;;.. :;IMIII;::: : \
WWWWWWWWWWWWWIIIIIIii;;::..;..;\WWWWWWWWIIII;::; :::::::::.....:: \
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%XXXXXXX
▄████ ▄ ▄ ███ ▄████ ▄███▄ ▄▄▄▄▄ ▄▄▄▄▀
█▀ ▀ █ █ █ █ █▀ ▀ █▀ ▀ █ ▀▄ ▀▀▀ █
█▀▀ █ ▄ █ █ ▀ ▄ █▀▀ ██▄▄ ▄ ▀▀▀▀▄ █
█ █ █ █ █ ▄▀ █ █▄ ▄▀ ▀▄▄▄▄▀ █
█ █ █ █ ███ █ ▀███▀ ▀
▀ ▀ ▀ ▀
*/
import "openzeppelin/token/ERC721/ERC721.sol";
import "openzeppelin/interfaces/IERC2981.sol";
import "openzeppelin/access/Ownable.sol";
import "openzeppelin/security/ReentrancyGuard.sol";
import "openzeppelin/utils/Counters.sol";
import "openzeppelin/utils/Strings.sol";
import "openzeppelin/utils/math/SafeMath.sol";
interface IERC20 {
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
contract Fest24 is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI =
"https://bronze-crowded-tuna-558.mypinata.cloud/ipfs/QmVxrXmWCYhR18vVk8pYAfmKNnTXg99WAKNJDWamxwWtY7";
bool public isPublicSaleActive = false;
uint256 public MAX_TICKETS = 299;
uint256 public MAX_PER_WALLET = 2;
uint256 public PUBLIC_SALE_PRICE = 55 ether;
uint256 public ROYALTY = 10;
address public FWB_ADDRESS = 0x35bD01FC9d6D5D81CA9E055Db88Dc49aa2c699A8;
address public FUNDS_RECIPIENT = 0x69602b7a324e927cfc47e6C5Ebfd9ED7754a964A;
/*
* ----------------------------------------------------------------------------
* Modifiers
* ----------------------------------------------------------------------------
*/
/*
* ----------------------------------------------------------------------------
* totalSupply Function
* ----------------------------------------------------------------------------
* This function returns the total supply of tokens.
* ----------------------------------------------------------------------------
*/
function totalSupply() public view returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* publicSaleActive Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the public sale is active.
* ----------------------------------------------------------------------------
*/
modifier publicSaleActive() {
}
/*
* ----------------------------------------------------------------------------
* canMintTicket Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the number of tickets to be minted does not exceed the maximum limit.
* ----------------------------------------------------------------------------
*/
modifier canMintTicket(uint256 numberOfTickets) {
require(<FILL_ME>)
_;
}
/*
* ----------------------------------------------------------------------------
* hasMinted Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the address has already minted the maximum number of tickets.
* ----------------------------------------------------------------------------
*/
modifier hasMinted(uint256 numberOfTickets) {
}
constructor() ERC721("FWB Fest", "FWBFEST") {}
/*
* ----------------------------------------------------------------------------
* mint Function
* ----------------------------------------------------------------------------
* This function mints the specified number of tickets and transfers the FWB from the sender to the recipient.
* ----------------------------------------------------------------------------
*/
function mint(
uint256 numberOfTickets
)
external
payable
nonReentrant
publicSaleActive
canMintTicket(numberOfTickets)
hasMinted(numberOfTickets)
{
}
/*
* ----------------------------------------------------------------------------
* mintOwner Function
* ----------------------------------------------------------------------------
* This function mints the specified number of tokens for the owner.
* ----------------------------------------------------------------------------
*/
function mintOwner(uint256 numberOfTokens) public onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* getBaseURI Function
* ----------------------------------------------------------------------------
* This function returns the base URI.
* ----------------------------------------------------------------------------
*/
function getBaseURI() external view returns (string memory) {
}
/*
* ----------------------------------------------------------------------------
* getLastTokenId Function
* ----------------------------------------------------------------------------
* This function returns the last token ID.
* ----------------------------------------------------------------------------
*/
function getLastTokenId() external view returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* Admin Functions
* ----------------------------------------------------------------------------
*/
/*
* ----------------------------------------------------------------------------
* setBaseURI Function
* ----------------------------------------------------------------------------
* This function sets the base URI.
* ----------------------------------------------------------------------------
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setFWBAddress Function
* ----------------------------------------------------------------------------
* This function sets the FWB token address.
* ----------------------------------------------------------------------------
*/
function setFWBAddress(address _address) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setNumTickets Function
* ----------------------------------------------------------------------------
* This function sets the number of tickets.
* ----------------------------------------------------------------------------
*/
function setNumTickets(uint256 _num) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setPrice Function
* ----------------------------------------------------------------------------
* This function sets the price of each ticket.
* Formatted so that you can disregard the decimal point when inputting (ex. 100 = 100 FWB)
* ----------------------------------------------------------------------------
*/
function setPrice(uint256 _price) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setMaxPerWallet Function
* ----------------------------------------------------------------------------
* This function sets the maximum number of tickets per wallet.
* ----------------------------------------------------------------------------
*/
function setMaxPerWallet(uint256 _max) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setRoyalty Function
* ----------------------------------------------------------------------------
* This function sets the royalty percentage.
* ----------------------------------------------------------------------------
*/
function setRoyalty(uint256 _royalty) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setFundsRecipient Function
* ----------------------------------------------------------------------------
* This function sets the address to which the funds will be sent.
* ----------------------------------------------------------------------------
*/
function setFundsRecipient(address _address) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setIsPublicSaleActive Function
* ----------------------------------------------------------------------------
* This function sets the status of the public sale.
* ----------------------------------------------------------------------------
*/
function setIsPublicSaleActive(
bool _isPublicSaleActive
) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* nextTokenId Function
* ----------------------------------------------------------------------------
* This function increments the token counter and returns the current token ID.
* ----------------------------------------------------------------------------
*/
function nextTokenId() private returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* supportsInterface Function
* ----------------------------------------------------------------------------
* This function checks if the contract supports the specified interface.
* ----------------------------------------------------------------------------
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721, IERC165) returns (bool) {
}
/*
* ----------------------------------------------------------------------------
* withdrawFunds Function
* ----------------------------------------------------------------------------
* This function allows the owner to withdraw funds.
* ----------------------------------------------------------------------------
*/
function withdrawFunds() public payable onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* tokenURI Function
* ----------------------------------------------------------------------------
* This function returns the URI of the specified token.
* ----------------------------------------------------------------------------
*/
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
/*
* ----------------------------------------------------------------------------
* royaltyInfo Function
* ----------------------------------------------------------------------------
* This function returns the receiver address and the royalty amount for the specified token and sale price.
* ----------------------------------------------------------------------------
*/
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view override returns (address receiver, uint256 royaltyAmount) {
}
}
| tokenCounter.current()+numberOfTickets<=MAX_TICKETS,"Not enough tickets remaining to mint" | 444,447 | tokenCounter.current()+numberOfTickets<=MAX_TICKETS |
"This address has already minted the maximum number of tickets." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
/*
. . . . . .
. . * . . . .
. . . * FWB FEST 2024
. ____ . . . . Idyllwild, CA
>> . . .
. . /WWWI; \ . . . ____ . . .
* /WWWWII; \=====; . /WI; \ * . /\_ .
. /WWWWWII;.. \_ . ___/WI;:. \ . _/M; \ . . .
/WWWWWIIIIi;.. \__/WWWIIII:.. \____ . . /MMI: \ * .
. _/WWWWWIIIi;;;:...: ;\WWWWWWIIIII;. \ /MMWII; \ . . .
/WWWWWIWIiii;;;.:.. : ;\WWWWWIII;;;:: \___/MMWIIII; \ .
/WWWWWIIIIiii;;::.... : ;|WWWWWWII;;::.: :;IMWIIIII;: \___ *
/WWWWWWWWWIIIIIWIIii;;::;..;\WWWWWWIII;;;:::... ;IMIII;; :: \ .
WWWWWWWWWIIIIIIIIIii;;::.;..;\WWWWWWWWIIIII;;.. :;IMIII;::: : \
WWWWWWWWWWWWWIIIIIIii;;::..;..;\WWWWWWWWIIII;::; :::::::::.....:: \
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%XXXXXXX
▄████ ▄ ▄ ███ ▄████ ▄███▄ ▄▄▄▄▄ ▄▄▄▄▀
█▀ ▀ █ █ █ █ █▀ ▀ █▀ ▀ █ ▀▄ ▀▀▀ █
█▀▀ █ ▄ █ █ ▀ ▄ █▀▀ ██▄▄ ▄ ▀▀▀▀▄ █
█ █ █ █ █ ▄▀ █ █▄ ▄▀ ▀▄▄▄▄▀ █
█ █ █ █ ███ █ ▀███▀ ▀
▀ ▀ ▀ ▀
*/
import "openzeppelin/token/ERC721/ERC721.sol";
import "openzeppelin/interfaces/IERC2981.sol";
import "openzeppelin/access/Ownable.sol";
import "openzeppelin/security/ReentrancyGuard.sol";
import "openzeppelin/utils/Counters.sol";
import "openzeppelin/utils/Strings.sol";
import "openzeppelin/utils/math/SafeMath.sol";
interface IERC20 {
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
contract Fest24 is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI =
"https://bronze-crowded-tuna-558.mypinata.cloud/ipfs/QmVxrXmWCYhR18vVk8pYAfmKNnTXg99WAKNJDWamxwWtY7";
bool public isPublicSaleActive = false;
uint256 public MAX_TICKETS = 299;
uint256 public MAX_PER_WALLET = 2;
uint256 public PUBLIC_SALE_PRICE = 55 ether;
uint256 public ROYALTY = 10;
address public FWB_ADDRESS = 0x35bD01FC9d6D5D81CA9E055Db88Dc49aa2c699A8;
address public FUNDS_RECIPIENT = 0x69602b7a324e927cfc47e6C5Ebfd9ED7754a964A;
/*
* ----------------------------------------------------------------------------
* Modifiers
* ----------------------------------------------------------------------------
*/
/*
* ----------------------------------------------------------------------------
* totalSupply Function
* ----------------------------------------------------------------------------
* This function returns the total supply of tokens.
* ----------------------------------------------------------------------------
*/
function totalSupply() public view returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* publicSaleActive Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the public sale is active.
* ----------------------------------------------------------------------------
*/
modifier publicSaleActive() {
}
/*
* ----------------------------------------------------------------------------
* canMintTicket Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the number of tickets to be minted does not exceed the maximum limit.
* ----------------------------------------------------------------------------
*/
modifier canMintTicket(uint256 numberOfTickets) {
}
/*
* ----------------------------------------------------------------------------
* hasMinted Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the address has already minted the maximum number of tickets.
* ----------------------------------------------------------------------------
*/
modifier hasMinted(uint256 numberOfTickets) {
require(<FILL_ME>)
_;
}
constructor() ERC721("FWB Fest", "FWBFEST") {}
/*
* ----------------------------------------------------------------------------
* mint Function
* ----------------------------------------------------------------------------
* This function mints the specified number of tickets and transfers the FWB from the sender to the recipient.
* ----------------------------------------------------------------------------
*/
function mint(
uint256 numberOfTickets
)
external
payable
nonReentrant
publicSaleActive
canMintTicket(numberOfTickets)
hasMinted(numberOfTickets)
{
}
/*
* ----------------------------------------------------------------------------
* mintOwner Function
* ----------------------------------------------------------------------------
* This function mints the specified number of tokens for the owner.
* ----------------------------------------------------------------------------
*/
function mintOwner(uint256 numberOfTokens) public onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* getBaseURI Function
* ----------------------------------------------------------------------------
* This function returns the base URI.
* ----------------------------------------------------------------------------
*/
function getBaseURI() external view returns (string memory) {
}
/*
* ----------------------------------------------------------------------------
* getLastTokenId Function
* ----------------------------------------------------------------------------
* This function returns the last token ID.
* ----------------------------------------------------------------------------
*/
function getLastTokenId() external view returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* Admin Functions
* ----------------------------------------------------------------------------
*/
/*
* ----------------------------------------------------------------------------
* setBaseURI Function
* ----------------------------------------------------------------------------
* This function sets the base URI.
* ----------------------------------------------------------------------------
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setFWBAddress Function
* ----------------------------------------------------------------------------
* This function sets the FWB token address.
* ----------------------------------------------------------------------------
*/
function setFWBAddress(address _address) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setNumTickets Function
* ----------------------------------------------------------------------------
* This function sets the number of tickets.
* ----------------------------------------------------------------------------
*/
function setNumTickets(uint256 _num) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setPrice Function
* ----------------------------------------------------------------------------
* This function sets the price of each ticket.
* Formatted so that you can disregard the decimal point when inputting (ex. 100 = 100 FWB)
* ----------------------------------------------------------------------------
*/
function setPrice(uint256 _price) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setMaxPerWallet Function
* ----------------------------------------------------------------------------
* This function sets the maximum number of tickets per wallet.
* ----------------------------------------------------------------------------
*/
function setMaxPerWallet(uint256 _max) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setRoyalty Function
* ----------------------------------------------------------------------------
* This function sets the royalty percentage.
* ----------------------------------------------------------------------------
*/
function setRoyalty(uint256 _royalty) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setFundsRecipient Function
* ----------------------------------------------------------------------------
* This function sets the address to which the funds will be sent.
* ----------------------------------------------------------------------------
*/
function setFundsRecipient(address _address) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setIsPublicSaleActive Function
* ----------------------------------------------------------------------------
* This function sets the status of the public sale.
* ----------------------------------------------------------------------------
*/
function setIsPublicSaleActive(
bool _isPublicSaleActive
) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* nextTokenId Function
* ----------------------------------------------------------------------------
* This function increments the token counter and returns the current token ID.
* ----------------------------------------------------------------------------
*/
function nextTokenId() private returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* supportsInterface Function
* ----------------------------------------------------------------------------
* This function checks if the contract supports the specified interface.
* ----------------------------------------------------------------------------
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721, IERC165) returns (bool) {
}
/*
* ----------------------------------------------------------------------------
* withdrawFunds Function
* ----------------------------------------------------------------------------
* This function allows the owner to withdraw funds.
* ----------------------------------------------------------------------------
*/
function withdrawFunds() public payable onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* tokenURI Function
* ----------------------------------------------------------------------------
* This function returns the URI of the specified token.
* ----------------------------------------------------------------------------
*/
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
/*
* ----------------------------------------------------------------------------
* royaltyInfo Function
* ----------------------------------------------------------------------------
* This function returns the receiver address and the royalty amount for the specified token and sale price.
* ----------------------------------------------------------------------------
*/
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view override returns (address receiver, uint256 royaltyAmount) {
}
}
| balanceOf(msg.sender)+numberOfTickets<=MAX_PER_WALLET,"This address has already minted the maximum number of tickets." | 444,447 | balanceOf(msg.sender)+numberOfTickets<=MAX_PER_WALLET |
"Payment failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
/*
. . . . . .
. . * . . . .
. . . * FWB FEST 2024
. ____ . . . . Idyllwild, CA
>> . . .
. . /WWWI; \ . . . ____ . . .
* /WWWWII; \=====; . /WI; \ * . /\_ .
. /WWWWWII;.. \_ . ___/WI;:. \ . _/M; \ . . .
/WWWWWIIIIi;.. \__/WWWIIII:.. \____ . . /MMI: \ * .
. _/WWWWWIIIi;;;:...: ;\WWWWWWIIIII;. \ /MMWII; \ . . .
/WWWWWIWIiii;;;.:.. : ;\WWWWWIII;;;:: \___/MMWIIII; \ .
/WWWWWIIIIiii;;::.... : ;|WWWWWWII;;::.: :;IMWIIIII;: \___ *
/WWWWWWWWWIIIIIWIIii;;::;..;\WWWWWWIII;;;:::... ;IMIII;; :: \ .
WWWWWWWWWIIIIIIIIIii;;::.;..;\WWWWWWWWIIIII;;.. :;IMIII;::: : \
WWWWWWWWWWWWWIIIIIIii;;::..;..;\WWWWWWWWIIII;::; :::::::::.....:: \
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%XXXXXXX
▄████ ▄ ▄ ███ ▄████ ▄███▄ ▄▄▄▄▄ ▄▄▄▄▀
█▀ ▀ █ █ █ █ █▀ ▀ █▀ ▀ █ ▀▄ ▀▀▀ █
█▀▀ █ ▄ █ █ ▀ ▄ █▀▀ ██▄▄ ▄ ▀▀▀▀▄ █
█ █ █ █ █ ▄▀ █ █▄ ▄▀ ▀▄▄▄▄▀ █
█ █ █ █ ███ █ ▀███▀ ▀
▀ ▀ ▀ ▀
*/
import "openzeppelin/token/ERC721/ERC721.sol";
import "openzeppelin/interfaces/IERC2981.sol";
import "openzeppelin/access/Ownable.sol";
import "openzeppelin/security/ReentrancyGuard.sol";
import "openzeppelin/utils/Counters.sol";
import "openzeppelin/utils/Strings.sol";
import "openzeppelin/utils/math/SafeMath.sol";
interface IERC20 {
function balanceOf(address owner) external view returns (uint256 balance);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
}
contract Fest24 is ERC721, IERC2981, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private tokenCounter;
string private baseURI =
"https://bronze-crowded-tuna-558.mypinata.cloud/ipfs/QmVxrXmWCYhR18vVk8pYAfmKNnTXg99WAKNJDWamxwWtY7";
bool public isPublicSaleActive = false;
uint256 public MAX_TICKETS = 299;
uint256 public MAX_PER_WALLET = 2;
uint256 public PUBLIC_SALE_PRICE = 55 ether;
uint256 public ROYALTY = 10;
address public FWB_ADDRESS = 0x35bD01FC9d6D5D81CA9E055Db88Dc49aa2c699A8;
address public FUNDS_RECIPIENT = 0x69602b7a324e927cfc47e6C5Ebfd9ED7754a964A;
/*
* ----------------------------------------------------------------------------
* Modifiers
* ----------------------------------------------------------------------------
*/
/*
* ----------------------------------------------------------------------------
* totalSupply Function
* ----------------------------------------------------------------------------
* This function returns the total supply of tokens.
* ----------------------------------------------------------------------------
*/
function totalSupply() public view returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* publicSaleActive Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the public sale is active.
* ----------------------------------------------------------------------------
*/
modifier publicSaleActive() {
}
/*
* ----------------------------------------------------------------------------
* canMintTicket Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the number of tickets to be minted does not exceed the maximum limit.
* ----------------------------------------------------------------------------
*/
modifier canMintTicket(uint256 numberOfTickets) {
}
/*
* ----------------------------------------------------------------------------
* hasMinted Modifier
* ----------------------------------------------------------------------------
* This modifier checks if the address has already minted the maximum number of tickets.
* ----------------------------------------------------------------------------
*/
modifier hasMinted(uint256 numberOfTickets) {
}
constructor() ERC721("FWB Fest", "FWBFEST") {}
/*
* ----------------------------------------------------------------------------
* mint Function
* ----------------------------------------------------------------------------
* This function mints the specified number of tickets and transfers the FWB from the sender to the recipient.
* ----------------------------------------------------------------------------
*/
function mint(
uint256 numberOfTickets
)
external
payable
nonReentrant
publicSaleActive
canMintTicket(numberOfTickets)
hasMinted(numberOfTickets)
{
require(<FILL_ME>)
for (uint256 i = 0; i < numberOfTickets; i++) {
_safeMint(msg.sender, nextTokenId());
}
}
/*
* ----------------------------------------------------------------------------
* mintOwner Function
* ----------------------------------------------------------------------------
* This function mints the specified number of tokens for the owner.
* ----------------------------------------------------------------------------
*/
function mintOwner(uint256 numberOfTokens) public onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* getBaseURI Function
* ----------------------------------------------------------------------------
* This function returns the base URI.
* ----------------------------------------------------------------------------
*/
function getBaseURI() external view returns (string memory) {
}
/*
* ----------------------------------------------------------------------------
* getLastTokenId Function
* ----------------------------------------------------------------------------
* This function returns the last token ID.
* ----------------------------------------------------------------------------
*/
function getLastTokenId() external view returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* Admin Functions
* ----------------------------------------------------------------------------
*/
/*
* ----------------------------------------------------------------------------
* setBaseURI Function
* ----------------------------------------------------------------------------
* This function sets the base URI.
* ----------------------------------------------------------------------------
*/
function setBaseURI(string memory _baseURI) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setFWBAddress Function
* ----------------------------------------------------------------------------
* This function sets the FWB token address.
* ----------------------------------------------------------------------------
*/
function setFWBAddress(address _address) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setNumTickets Function
* ----------------------------------------------------------------------------
* This function sets the number of tickets.
* ----------------------------------------------------------------------------
*/
function setNumTickets(uint256 _num) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setPrice Function
* ----------------------------------------------------------------------------
* This function sets the price of each ticket.
* Formatted so that you can disregard the decimal point when inputting (ex. 100 = 100 FWB)
* ----------------------------------------------------------------------------
*/
function setPrice(uint256 _price) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setMaxPerWallet Function
* ----------------------------------------------------------------------------
* This function sets the maximum number of tickets per wallet.
* ----------------------------------------------------------------------------
*/
function setMaxPerWallet(uint256 _max) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setRoyalty Function
* ----------------------------------------------------------------------------
* This function sets the royalty percentage.
* ----------------------------------------------------------------------------
*/
function setRoyalty(uint256 _royalty) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setFundsRecipient Function
* ----------------------------------------------------------------------------
* This function sets the address to which the funds will be sent.
* ----------------------------------------------------------------------------
*/
function setFundsRecipient(address _address) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* setIsPublicSaleActive Function
* ----------------------------------------------------------------------------
* This function sets the status of the public sale.
* ----------------------------------------------------------------------------
*/
function setIsPublicSaleActive(
bool _isPublicSaleActive
) external onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* nextTokenId Function
* ----------------------------------------------------------------------------
* This function increments the token counter and returns the current token ID.
* ----------------------------------------------------------------------------
*/
function nextTokenId() private returns (uint256) {
}
/*
* ----------------------------------------------------------------------------
* supportsInterface Function
* ----------------------------------------------------------------------------
* This function checks if the contract supports the specified interface.
* ----------------------------------------------------------------------------
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721, IERC165) returns (bool) {
}
/*
* ----------------------------------------------------------------------------
* withdrawFunds Function
* ----------------------------------------------------------------------------
* This function allows the owner to withdraw funds.
* ----------------------------------------------------------------------------
*/
function withdrawFunds() public payable onlyOwner {
}
/*
* ----------------------------------------------------------------------------
* tokenURI Function
* ----------------------------------------------------------------------------
* This function returns the URI of the specified token.
* ----------------------------------------------------------------------------
*/
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
}
/*
* ----------------------------------------------------------------------------
* royaltyInfo Function
* ----------------------------------------------------------------------------
* This function returns the receiver address and the royalty amount for the specified token and sale price.
* ----------------------------------------------------------------------------
*/
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view override returns (address receiver, uint256 royaltyAmount) {
}
}
| IERC20(FWB_ADDRESS).transferFrom(msg.sender,FUNDS_RECIPIENT,PUBLIC_SALE_PRICE*numberOfTickets),"Payment failed" | 444,447 | IERC20(FWB_ADDRESS).transferFrom(msg.sender,FUNDS_RECIPIENT,PUBLIC_SALE_PRICE*numberOfTickets) |
"Primes: total supply limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "./PrimesUtils.sol";
// @title Primes
// @author g56d
contract Primes is ERC721AQueryable, ERC2981, Ownable {
using Strings for uint256;
using PrimesUtils for *;
// Metadata
// --------
struct Scheme {
string color;
}
struct D {
string min;
string max;
}
mapping(uint256 => D) private Values;
mapping(uint256 => Scheme) private Color;
// Paths
// --------
function setValuesMap() internal {
}
function getMinValue(
uint256 k
) internal view returns (string memory values) {
}
function getMaxValue(
uint256 k
) internal view returns (string memory values) {
}
// Colors
// --------
function setColorsMap() internal {
}
function getColor(uint256 k) internal view returns (string memory color) {
}
// Token URI
// --------
function tokenURI(
uint256 tokenId
) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
// SVG
// --------
function encodeSVG(uint256 tokenId) internal view returns (string memory) {
}
function generateSVG(
uint256 tokenId
) internal view returns (string memory) {
}
function SVG(uint256 tokenId) external view returns (string memory) {
}
// Paths
// --------
function generatePaths(
uint256 tokenId
) internal view returns (string memory) {
}
function generateTPath(
uint256 x,
uint256 count
) internal view returns (string memory) {
}
function getCoordinates(
uint x,
uint y
) internal pure returns (string memory) {
}
/**
* @param x coordinate
* @param y coordinate
* @param c incremented value
* @return d animation paths
*/
function getValues(
uint x,
uint y,
uint c,
uint d
) internal view returns (string memory) {
}
/**
* @param i index of array
* @param c incremented value
* @param d incremented value
* @return Concatenated animation values, min/max variation
*/
function concatValues(
uint i,
uint c,
uint d
) internal view returns (string memory) {
}
// Animation URL
function encodeHTML(uint256 tokenId) internal view returns (string memory) {
}
function generateHTML(
uint256 tokenId
) internal view returns (string memory) {
}
// EIP-165
// --------
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, ERC2981, IERC721A) returns (bool) {
}
// EIP-2981
// --------
function setDefaultRoyalty(
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
}
/**
* @dev Overrides the function from ERC721A to start at 1.
*/
function _startTokenId() internal view virtual override returns (uint256) {
}
constructor() ERC721A("Primes", "PRMS") {
}
function mint(address to, uint256 quantity) external onlyOwner {
require(<FILL_ME>)
_mint(to, quantity);
}
}
| totalSupply()+quantity<=1575,"Primes: total supply limit exceeded" | 444,464 | totalSupply()+quantity<=1575 |
"NT: can't be more than 10%" | //Telegram: https://t.me/NaughtyQuagmire
//Twitter: https://twitter.com/naughtyquagmire
// SPDX-License-Identifier:MIT
pragma solidity ^0.8.10;
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
);
}
// Dex Factory contract interface
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
// Dex Router contract interface
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract NAUGHTYQUAGMIRE is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isExcludedFromMaxTxn;
mapping(address => bool) public isExcludedFromMaxHolding;
mapping(address => bool) public isBot;
string private _name = "Naughty Quagmire";
string private _symbol = "$NQUAG";
uint8 private _decimals = 9;
uint256 private _totalSupply = 1_000_000 * 1e12;
address private constant DEAD = address(0xdead);
address private constant ZERO = address(0);
IDexRouter public dexRouter;
address public dexPair;
address public marketingWallet;
uint256 public minTokenToSwap = _totalSupply.div(1e5); // this amount will trigger swap and distribute
uint256 public maxHoldLimit = _totalSupply.div(100); // this is the max wallet holding limit
uint256 public maxTxnLimit = _totalSupply.div(100); // this is the max transaction limit
uint256 public botFee = 990;
uint256 public percentDivider = 1000;
uint256 public snipingTime = 60 seconds;
uint256 public launchedAt;
bool public distributeAndLiquifyStatus; // should be true to turn on to liquidate the pool
bool public feesStatus; // enable by default
bool public trading; // once enable can't be disable afterwards
uint256 public liquidityFeeOnBuying = 10; // 1% will be added to the liquidity
uint256 public marketingFeeOnBuying = 30; // 3% will be added to the marketing address
uint256 public liquidityFeeOnSelling = 10; // 1% will be added to the liquidity
uint256 public marketingFeeOnSelling = 150; // 3% will be added to the marketing address
uint256 liquidityFeeCounter = 0;
uint256 marketingFeeCounter = 0;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
constructor() {
}
//to receive ETH from dexRouter when swapping
receive() external payable {}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function includeOrExcludeFromFee(address account, bool value)
external
onlyOwner
{
}
function includeOrExcludeFromMaxTxn(address account, bool value)
external
onlyOwner
{
}
function includeOrExcludeFromMaxHolding(address account, bool value)
external
onlyOwner
{
}
function setMinTokenToSwap(uint256 _amount) external onlyOwner {
}
function setMaxHoldLimit(uint256 _amount) external onlyOwner {
}
function setMaxTxnLimit(uint256 _amount) external onlyOwner {
}
function setBuyFeePercent(
uint256 _lpFee,
uint256 _marketingFee
) external onlyOwner {
marketingFeeOnBuying = _lpFee;
liquidityFeeOnBuying = _marketingFee;
require(<FILL_ME>)
}
function setSellFeePercent(
uint256 _lpFee,
uint256 _marketingFee
) external onlyOwner {
}
function setDistributionStatus(bool _value) public onlyOwner {
}
function enableOrDisableFees(bool _value) external onlyOwner {
}
function updateAddresses(address _marketingWallet) external onlyOwner {
}
function setIsBot(address holder, bool exempt)
external
onlyOwner
{
}
function enableTrading() external onlyOwner {
}
function removeStuckEth(address _receiver) public onlyOwner {
}
function totalBuyFeePerTx(uint256 amount) public view returns (uint256) {
}
function totalSellFeePerTx(uint256 amount) public view returns (uint256) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
//this method is responsible for taking all fee, if takeFee is true
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function takeTokenFee(address sender, uint256 amount) private {
}
function setFeeCountersOnBuying(uint256 amount) private {
}
function setFeeCountersOnSelling(uint256 amount) private {
}
function distributeAndLiquify(address from, address to) private {
}
}
// Library for doing a swap on Dex
library Utils {
using SafeMath for uint256;
function swapTokensForEth(address routerAddress, uint256 tokenAmount)
internal
{
}
function addLiquidity(
address routerAddress,
address owner,
uint256 tokenAmount,
uint256 ethAmount
) internal {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
| _lpFee.add(_marketingFee)<=percentDivider.div(10),"NT: can't be more than 10%" | 444,479 | _lpFee.add(_marketingFee)<=percentDivider.div(10) |
"Presale ended!" | //SPDX-License-Identifier: MIT Licensed
pragma solidity ^0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
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() {
}
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external;
function transfer(address to, uint256 value) external;
function transferFrom(
address from,
address to,
uint256 value
) external;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract Presale is Ownable {
IERC20 public mainToken;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
AggregatorV3Interface public priceFeed;
struct Phase {
uint256 endTime;
uint256 tokensToSell;
uint256 totalSoldTokens;
uint256 tokenPerUsdPrice;
}
mapping(uint256 => Phase) public phases;
// Stats
uint256 public totalStages;
uint256 public currentStage;
uint256 public soldToken;
uint256 public amountRaised;
uint256 public amountRaisedUSDT;
uint256 public uniqueBuyers;
address payable public fundReceiver;
bool public presaleStatus;
bool public isPresaleEnded;
uint256 public claimStartTime;
address[] public UsersAddresses;
struct User {
uint256 native_balance;
uint256 usdt_balance;
uint256 token_balance;
uint256 claimed_tokens;
}
mapping(address => User) public users;
mapping(address => bool) public isExist;
event BuyToken(address indexed _user, uint256 indexed _amount);
event ClaimToken(address indexed _user, uint256 indexed _amount);
event UpdatePrice(uint256 _oldPrice, uint256 _newPrice);
constructor(
IERC20 _token,
uint256[] memory tokensToSell,
uint256[] memory endTimestamps,
uint256[] memory tokenPerUsdPrice
) {
}
// to get real time price of Eth
function getLatestPrice() public view returns (uint256) {
}
// to buy token during preSale time with Eth => for web3 use
function buyToken() public payable {
require(<FILL_ME>)
require(presaleStatus, " Presale is Paused, check back later");
if (!isExist[msg.sender]) {
isExist[msg.sender] = true;
uniqueBuyers++;
UsersAddresses.push(msg.sender);
}
fundReceiver.transfer(msg.value);
// Check active phase
uint256 activePhase = activePhaseInd();
if (activePhase != currentStage) {
currentStage = activePhase;
}
uint256 numberOfTokens;
numberOfTokens = nativeToToken(msg.value, activePhase);
require(
phases[currentStage].totalSoldTokens + numberOfTokens <=
phases[currentStage].tokensToSell,
"Phase Limit Reached"
);
soldToken = soldToken + (numberOfTokens);
amountRaised = amountRaised + (msg.value);
users[msg.sender].native_balance =
users[msg.sender].native_balance +
(msg.value);
users[msg.sender].token_balance =
users[msg.sender].token_balance +
(numberOfTokens);
phases[currentStage].totalSoldTokens += numberOfTokens;
}
// to buy token during preSale time with USDT => for web3 use
function buyTokenUSDT(uint256 amount) public {
}
function claimTokens() external {
}
function activePhaseInd() public view returns (uint256) {
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function getPhaseDetail(uint256 phaseInd)
external
view
returns (
uint256 tokenToSell,
uint256 soldTokens,
uint256 priceUsd,
uint256 duration
)
{
}
function setPresaleStatus(bool _status) external onlyOwner {
}
function endPresale() external onlyOwner {
}
// to check number of token for given Eth
function nativeToToken(uint256 _amount, uint256 phaseId)
public
view
returns (uint256)
{
}
// to check number of token for given usdt
function usdtToToken(uint256 _amount, uint256 phaseId)
public
view
returns (uint256)
{
}
function updateInfos(
uint256 _sold,
uint256 _raised,
uint256 _raisedInUsdt
) external onlyOwner {
}
// change tokens
function updateToken(address _token) external onlyOwner {
}
function updateEndTime(uint256 _phase, uint256 _time) public onlyOwner {
}
//change tokens for buy
function updateStableTokens(IERC20 _USDT) external onlyOwner {
}
// to withdraw funds for liquidity
function initiateTransfer(uint256 _value) external onlyOwner {
}
function changeFundReciever(address _addr) external onlyOwner {
}
function updatePriceFeed(AggregatorV3Interface _priceFeed)
external
onlyOwner
{
}
// to withdraw out tokens
function transferTokens(IERC20 token, uint256 _value) external onlyOwner {
}
}
| !isPresaleEnded,"Presale ended!" | 444,747 | !isPresaleEnded |
"Phase Limit Reached" | //SPDX-License-Identifier: MIT Licensed
pragma solidity ^0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
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() {
}
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external;
function transfer(address to, uint256 value) external;
function transferFrom(
address from,
address to,
uint256 value
) external;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract Presale is Ownable {
IERC20 public mainToken;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
AggregatorV3Interface public priceFeed;
struct Phase {
uint256 endTime;
uint256 tokensToSell;
uint256 totalSoldTokens;
uint256 tokenPerUsdPrice;
}
mapping(uint256 => Phase) public phases;
// Stats
uint256 public totalStages;
uint256 public currentStage;
uint256 public soldToken;
uint256 public amountRaised;
uint256 public amountRaisedUSDT;
uint256 public uniqueBuyers;
address payable public fundReceiver;
bool public presaleStatus;
bool public isPresaleEnded;
uint256 public claimStartTime;
address[] public UsersAddresses;
struct User {
uint256 native_balance;
uint256 usdt_balance;
uint256 token_balance;
uint256 claimed_tokens;
}
mapping(address => User) public users;
mapping(address => bool) public isExist;
event BuyToken(address indexed _user, uint256 indexed _amount);
event ClaimToken(address indexed _user, uint256 indexed _amount);
event UpdatePrice(uint256 _oldPrice, uint256 _newPrice);
constructor(
IERC20 _token,
uint256[] memory tokensToSell,
uint256[] memory endTimestamps,
uint256[] memory tokenPerUsdPrice
) {
}
// to get real time price of Eth
function getLatestPrice() public view returns (uint256) {
}
// to buy token during preSale time with Eth => for web3 use
function buyToken() public payable {
require(!isPresaleEnded, "Presale ended!");
require(presaleStatus, " Presale is Paused, check back later");
if (!isExist[msg.sender]) {
isExist[msg.sender] = true;
uniqueBuyers++;
UsersAddresses.push(msg.sender);
}
fundReceiver.transfer(msg.value);
// Check active phase
uint256 activePhase = activePhaseInd();
if (activePhase != currentStage) {
currentStage = activePhase;
}
uint256 numberOfTokens;
numberOfTokens = nativeToToken(msg.value, activePhase);
require(<FILL_ME>)
soldToken = soldToken + (numberOfTokens);
amountRaised = amountRaised + (msg.value);
users[msg.sender].native_balance =
users[msg.sender].native_balance +
(msg.value);
users[msg.sender].token_balance =
users[msg.sender].token_balance +
(numberOfTokens);
phases[currentStage].totalSoldTokens += numberOfTokens;
}
// to buy token during preSale time with USDT => for web3 use
function buyTokenUSDT(uint256 amount) public {
}
function claimTokens() external {
}
function activePhaseInd() public view returns (uint256) {
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function getPhaseDetail(uint256 phaseInd)
external
view
returns (
uint256 tokenToSell,
uint256 soldTokens,
uint256 priceUsd,
uint256 duration
)
{
}
function setPresaleStatus(bool _status) external onlyOwner {
}
function endPresale() external onlyOwner {
}
// to check number of token for given Eth
function nativeToToken(uint256 _amount, uint256 phaseId)
public
view
returns (uint256)
{
}
// to check number of token for given usdt
function usdtToToken(uint256 _amount, uint256 phaseId)
public
view
returns (uint256)
{
}
function updateInfos(
uint256 _sold,
uint256 _raised,
uint256 _raisedInUsdt
) external onlyOwner {
}
// change tokens
function updateToken(address _token) external onlyOwner {
}
function updateEndTime(uint256 _phase, uint256 _time) public onlyOwner {
}
//change tokens for buy
function updateStableTokens(IERC20 _USDT) external onlyOwner {
}
// to withdraw funds for liquidity
function initiateTransfer(uint256 _value) external onlyOwner {
}
function changeFundReciever(address _addr) external onlyOwner {
}
function updatePriceFeed(AggregatorV3Interface _priceFeed)
external
onlyOwner
{
}
// to withdraw out tokens
function transferTokens(IERC20 token, uint256 _value) external onlyOwner {
}
}
| phases[currentStage].totalSoldTokens+numberOfTokens<=phases[currentStage].tokensToSell,"Phase Limit Reached" | 444,747 | phases[currentStage].totalSoldTokens+numberOfTokens<=phases[currentStage].tokensToSell |
"User don't exist" | //SPDX-License-Identifier: MIT Licensed
pragma solidity ^0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract Ownable is Context {
address private _owner;
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() {
}
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external;
function transfer(address to, uint256 value) external;
function transferFrom(
address from,
address to,
uint256 value
) external;
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
contract Presale is Ownable {
IERC20 public mainToken;
IERC20 public USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7);
AggregatorV3Interface public priceFeed;
struct Phase {
uint256 endTime;
uint256 tokensToSell;
uint256 totalSoldTokens;
uint256 tokenPerUsdPrice;
}
mapping(uint256 => Phase) public phases;
// Stats
uint256 public totalStages;
uint256 public currentStage;
uint256 public soldToken;
uint256 public amountRaised;
uint256 public amountRaisedUSDT;
uint256 public uniqueBuyers;
address payable public fundReceiver;
bool public presaleStatus;
bool public isPresaleEnded;
uint256 public claimStartTime;
address[] public UsersAddresses;
struct User {
uint256 native_balance;
uint256 usdt_balance;
uint256 token_balance;
uint256 claimed_tokens;
}
mapping(address => User) public users;
mapping(address => bool) public isExist;
event BuyToken(address indexed _user, uint256 indexed _amount);
event ClaimToken(address indexed _user, uint256 indexed _amount);
event UpdatePrice(uint256 _oldPrice, uint256 _newPrice);
constructor(
IERC20 _token,
uint256[] memory tokensToSell,
uint256[] memory endTimestamps,
uint256[] memory tokenPerUsdPrice
) {
}
// to get real time price of Eth
function getLatestPrice() public view returns (uint256) {
}
// to buy token during preSale time with Eth => for web3 use
function buyToken() public payable {
}
// to buy token during preSale time with USDT => for web3 use
function buyTokenUSDT(uint256 amount) public {
}
function claimTokens() external {
require(isPresaleEnded, "Presale has not ended yet");
require(<FILL_ME>)
User storage user = users[msg.sender];
require(user.token_balance > 0, "No tokens purchased");
uint256 claimableTokens = user.token_balance - user.claimed_tokens;
require(claimableTokens > 0, "No tokens to claim");
user.claimed_tokens += claimableTokens;
mainToken.transfer(msg.sender, claimableTokens);
emit ClaimToken(msg.sender, claimableTokens);
}
function activePhaseInd() public view returns (uint256) {
}
function changeClaimAddress(address _oldAddress, address _newWallet)
public
onlyOwner
{
}
function getPhaseDetail(uint256 phaseInd)
external
view
returns (
uint256 tokenToSell,
uint256 soldTokens,
uint256 priceUsd,
uint256 duration
)
{
}
function setPresaleStatus(bool _status) external onlyOwner {
}
function endPresale() external onlyOwner {
}
// to check number of token for given Eth
function nativeToToken(uint256 _amount, uint256 phaseId)
public
view
returns (uint256)
{
}
// to check number of token for given usdt
function usdtToToken(uint256 _amount, uint256 phaseId)
public
view
returns (uint256)
{
}
function updateInfos(
uint256 _sold,
uint256 _raised,
uint256 _raisedInUsdt
) external onlyOwner {
}
// change tokens
function updateToken(address _token) external onlyOwner {
}
function updateEndTime(uint256 _phase, uint256 _time) public onlyOwner {
}
//change tokens for buy
function updateStableTokens(IERC20 _USDT) external onlyOwner {
}
// to withdraw funds for liquidity
function initiateTransfer(uint256 _value) external onlyOwner {
}
function changeFundReciever(address _addr) external onlyOwner {
}
function updatePriceFeed(AggregatorV3Interface _priceFeed)
external
onlyOwner
{
}
// to withdraw out tokens
function transferTokens(IERC20 token, uint256 _value) external onlyOwner {
}
}
| isExist[msg.sender],"User don't exist" | 444,747 | isExist[msg.sender] |
"Can only mint once during public AL!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "./MerkleAllowlist.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract DegenAwakening is Ownable, ERC721A, MerkleAllowlist, ReentrancyGuard, ERC721ABurnable{
string public CONTRACT_URI = "";
mapping(address => bool) public userHasMintedPublicAL;
bool public REVEALED;
string public UNREVEALED_URI = "https://images.squarespace-cdn.com/content/v1/582b72e2be659482710510ae/1667319843951-4C3PVYTRVFXVPH2G8HVC/Degen+%2833%29.png";
string public BASE_URI;
bool public isPublicMintEnabled = false;
uint public COLLECTION_SIZE = 700;
uint public MINT_PRICE = 0.03 ether;
uint public AL_MINT_PRICE = 0.01 ether;
uint public MAX_BATCH_SIZE = 3;
uint public MAX_AL_BATCH_SIZE = 1;
constructor() ERC721A("DegenAwakening", "DA") {}
function teamMint(uint256 quantity, address receiver) public onlyOwner {
}
function mintPublicAL(uint256 quantity, bytes32[] memory proof)
public
payable
onlyPublicAllowlist(proof)
{
uint256 price = (AL_MINT_PRICE) * quantity;
require(<FILL_ME>)
require(totalSupply() + quantity <= COLLECTION_SIZE, "Max collection size reached!");
require(quantity <= MAX_AL_BATCH_SIZE, "Cannot mint this quantity");
require(msg.value >= price, "Must send enough eth for AL Mint");
userHasMintedPublicAL[msg.sender] = true;
// Mint them
_safeMint(msg.sender, quantity);
if (msg.value > price) {
payable(msg.sender).transfer(msg.value - price);
}
}
modifier callerIsUser() {
}
function publicSaleMint(uint256 quantity)
external
payable
callerIsUser
{
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function setPublicMintEnabled(bool _isPublicMintEnabled) public onlyOwner {
}
function setBaseURI(bool _revealed, string memory _baseURI) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory _contractURI) public onlyOwner {
}
function setALMintPrice(uint256 _mintPrice) public onlyOwner {
}
function setMintPrice(uint256 _mintPrice) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
override (ERC721A, IERC721A)
returns (string memory)
{
}
}
| !userHasMintedPublicAL[msg.sender],"Can only mint once during public AL!" | 444,981 | !userHasMintedPublicAL[msg.sender] |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IReflectionToken {
function getPendingRewardByVoting() external view returns(uint256);
function distributeRewardByVoting(address, uint256) external;
function getCurrentSnapshotId() external view returns(uint256);
function balanceOfAt(address, uint256) external view returns(uint256);
function snapshot() external returns(uint256);
}
contract DaoVoting is Ownable, ReentrancyGuard {
uint private timeOut = 2 days;
// Minimum number of yes votes required to win = 200k
uint public minVotes = 2 * 10 ** 23;
IReflectionToken public reflectionToken;
// Structure for votes
struct Votes {
uint256 voteStartingTime;
bool voteActive;
mapping(address=>uint8) voters;
address[] voterList;
uint256 yesPower;
uint256 noPower;
address receiver;
uint256 amount;
uint256 snapshotId;
}
// Variable for vote structure
Votes public election;
// Initialization function (takes the address of the token)
constructor( address _reflection) {
}
function strToBytes32(string memory _string) internal pure returns(bytes32) {
}
function startVote(address _newWallet, uint256 _amount) public {
require(<FILL_ME>)
_amount = _amount * (10 ** 18); // assume that submitters will not add decimals manually
// Check if amount is correct
uint256 pendingAmount = reflectionToken.getPendingRewardByVoting();
require(_amount > 0 && _amount <= pendingAmount);
uint256 snapshotId = reflectionToken.snapshot();
require(snapshotId > 0);
require(reflectionToken.balanceOfAt(_msgSender(), snapshotId) > 0);
election.receiver = _newWallet;
election.voteStartingTime = block.timestamp;
election.voteActive = true;
election.amount = _amount;
election.snapshotId = snapshotId;
}
// Voting function
function vote(uint8 _answer) public {
}
// Function to voting
function finishCurrentVote() public nonReentrant returns(uint8){
}
}
| !election.voteActive | 444,994 | !election.voteActive |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IReflectionToken {
function getPendingRewardByVoting() external view returns(uint256);
function distributeRewardByVoting(address, uint256) external;
function getCurrentSnapshotId() external view returns(uint256);
function balanceOfAt(address, uint256) external view returns(uint256);
function snapshot() external returns(uint256);
}
contract DaoVoting is Ownable, ReentrancyGuard {
uint private timeOut = 2 days;
// Minimum number of yes votes required to win = 200k
uint public minVotes = 2 * 10 ** 23;
IReflectionToken public reflectionToken;
// Structure for votes
struct Votes {
uint256 voteStartingTime;
bool voteActive;
mapping(address=>uint8) voters;
address[] voterList;
uint256 yesPower;
uint256 noPower;
address receiver;
uint256 amount;
uint256 snapshotId;
}
// Variable for vote structure
Votes public election;
// Initialization function (takes the address of the token)
constructor( address _reflection) {
}
function strToBytes32(string memory _string) internal pure returns(bytes32) {
}
function startVote(address _newWallet, uint256 _amount) public {
require(!election.voteActive);
_amount = _amount * (10 ** 18); // assume that submitters will not add decimals manually
// Check if amount is correct
uint256 pendingAmount = reflectionToken.getPendingRewardByVoting();
require(_amount > 0 && _amount <= pendingAmount);
uint256 snapshotId = reflectionToken.snapshot();
require(snapshotId > 0);
require(<FILL_ME>)
election.receiver = _newWallet;
election.voteStartingTime = block.timestamp;
election.voteActive = true;
election.amount = _amount;
election.snapshotId = snapshotId;
}
// Voting function
function vote(uint8 _answer) public {
}
// Function to voting
function finishCurrentVote() public nonReentrant returns(uint8){
}
}
| reflectionToken.balanceOfAt(_msgSender(),snapshotId)>0 | 444,994 | reflectionToken.balanceOfAt(_msgSender(),snapshotId)>0 |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IReflectionToken {
function getPendingRewardByVoting() external view returns(uint256);
function distributeRewardByVoting(address, uint256) external;
function getCurrentSnapshotId() external view returns(uint256);
function balanceOfAt(address, uint256) external view returns(uint256);
function snapshot() external returns(uint256);
}
contract DaoVoting is Ownable, ReentrancyGuard {
uint private timeOut = 2 days;
// Minimum number of yes votes required to win = 200k
uint public minVotes = 2 * 10 ** 23;
IReflectionToken public reflectionToken;
// Structure for votes
struct Votes {
uint256 voteStartingTime;
bool voteActive;
mapping(address=>uint8) voters;
address[] voterList;
uint256 yesPower;
uint256 noPower;
address receiver;
uint256 amount;
uint256 snapshotId;
}
// Variable for vote structure
Votes public election;
// Initialization function (takes the address of the token)
constructor( address _reflection) {
}
function strToBytes32(string memory _string) internal pure returns(bytes32) {
}
function startVote(address _newWallet, uint256 _amount) public {
}
// Voting function
function vote(uint8 _answer) public {
// Verify that the vote is in progress
require(<FILL_ME>)
// Check that there is at least one token
require(reflectionToken.balanceOfAt(_msgSender(), election.snapshotId)> 0);
// Cehck _answer mustbe 1 or 2
require(_answer <= 2 && _answer > 0);
// Check if user already voted
require(election.voters[_msgSender()]==0);
// Check if vote is in progress
require(election.voteStartingTime <= block.timestamp && election.voteStartingTime + timeOut >= block.timestamp);
if( _answer == 1 ) {
election.yesPower += reflectionToken.balanceOfAt(_msgSender(),election.snapshotId);
} else {
election.noPower += reflectionToken.balanceOfAt(_msgSender(),election.snapshotId);
}
election.voters[_msgSender()] = _answer;
election.voterList.push(_msgSender());
}
// Function to voting
function finishCurrentVote() public nonReentrant returns(uint8){
}
}
| election.voteActive | 444,994 | election.voteActive |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IReflectionToken {
function getPendingRewardByVoting() external view returns(uint256);
function distributeRewardByVoting(address, uint256) external;
function getCurrentSnapshotId() external view returns(uint256);
function balanceOfAt(address, uint256) external view returns(uint256);
function snapshot() external returns(uint256);
}
contract DaoVoting is Ownable, ReentrancyGuard {
uint private timeOut = 2 days;
// Minimum number of yes votes required to win = 200k
uint public minVotes = 2 * 10 ** 23;
IReflectionToken public reflectionToken;
// Structure for votes
struct Votes {
uint256 voteStartingTime;
bool voteActive;
mapping(address=>uint8) voters;
address[] voterList;
uint256 yesPower;
uint256 noPower;
address receiver;
uint256 amount;
uint256 snapshotId;
}
// Variable for vote structure
Votes public election;
// Initialization function (takes the address of the token)
constructor( address _reflection) {
}
function strToBytes32(string memory _string) internal pure returns(bytes32) {
}
function startVote(address _newWallet, uint256 _amount) public {
}
// Voting function
function vote(uint8 _answer) public {
// Verify that the vote is in progress
require(election.voteActive);
// Check that there is at least one token
require(<FILL_ME>)
// Cehck _answer mustbe 1 or 2
require(_answer <= 2 && _answer > 0);
// Check if user already voted
require(election.voters[_msgSender()]==0);
// Check if vote is in progress
require(election.voteStartingTime <= block.timestamp && election.voteStartingTime + timeOut >= block.timestamp);
if( _answer == 1 ) {
election.yesPower += reflectionToken.balanceOfAt(_msgSender(),election.snapshotId);
} else {
election.noPower += reflectionToken.balanceOfAt(_msgSender(),election.snapshotId);
}
election.voters[_msgSender()] = _answer;
election.voterList.push(_msgSender());
}
// Function to voting
function finishCurrentVote() public nonReentrant returns(uint8){
}
}
| reflectionToken.balanceOfAt(_msgSender(),election.snapshotId)>0 | 444,994 | reflectionToken.balanceOfAt(_msgSender(),election.snapshotId)>0 |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IReflectionToken {
function getPendingRewardByVoting() external view returns(uint256);
function distributeRewardByVoting(address, uint256) external;
function getCurrentSnapshotId() external view returns(uint256);
function balanceOfAt(address, uint256) external view returns(uint256);
function snapshot() external returns(uint256);
}
contract DaoVoting is Ownable, ReentrancyGuard {
uint private timeOut = 2 days;
// Minimum number of yes votes required to win = 200k
uint public minVotes = 2 * 10 ** 23;
IReflectionToken public reflectionToken;
// Structure for votes
struct Votes {
uint256 voteStartingTime;
bool voteActive;
mapping(address=>uint8) voters;
address[] voterList;
uint256 yesPower;
uint256 noPower;
address receiver;
uint256 amount;
uint256 snapshotId;
}
// Variable for vote structure
Votes public election;
// Initialization function (takes the address of the token)
constructor( address _reflection) {
}
function strToBytes32(string memory _string) internal pure returns(bytes32) {
}
function startVote(address _newWallet, uint256 _amount) public {
}
// Voting function
function vote(uint8 _answer) public {
// Verify that the vote is in progress
require(election.voteActive);
// Check that there is at least one token
require(reflectionToken.balanceOfAt(_msgSender(), election.snapshotId)> 0);
// Cehck _answer mustbe 1 or 2
require(_answer <= 2 && _answer > 0);
// Check if user already voted
require(<FILL_ME>)
// Check if vote is in progress
require(election.voteStartingTime <= block.timestamp && election.voteStartingTime + timeOut >= block.timestamp);
if( _answer == 1 ) {
election.yesPower += reflectionToken.balanceOfAt(_msgSender(),election.snapshotId);
} else {
election.noPower += reflectionToken.balanceOfAt(_msgSender(),election.snapshotId);
}
election.voters[_msgSender()] = _answer;
election.voterList.push(_msgSender());
}
// Function to voting
function finishCurrentVote() public nonReentrant returns(uint8){
}
}
| election.voters[_msgSender()]==0 | 444,994 | election.voters[_msgSender()]==0 |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IReflectionToken {
function getPendingRewardByVoting() external view returns(uint256);
function distributeRewardByVoting(address, uint256) external;
function getCurrentSnapshotId() external view returns(uint256);
function balanceOfAt(address, uint256) external view returns(uint256);
function snapshot() external returns(uint256);
}
contract DaoVoting is Ownable, ReentrancyGuard {
uint private timeOut = 2 days;
// Minimum number of yes votes required to win = 200k
uint public minVotes = 2 * 10 ** 23;
IReflectionToken public reflectionToken;
// Structure for votes
struct Votes {
uint256 voteStartingTime;
bool voteActive;
mapping(address=>uint8) voters;
address[] voterList;
uint256 yesPower;
uint256 noPower;
address receiver;
uint256 amount;
uint256 snapshotId;
}
// Variable for vote structure
Votes public election;
// Initialization function (takes the address of the token)
constructor( address _reflection) {
}
function strToBytes32(string memory _string) internal pure returns(bytes32) {
}
function startVote(address _newWallet, uint256 _amount) public {
}
// Voting function
function vote(uint8 _answer) public {
}
// Function to voting
function finishCurrentVote() public nonReentrant returns(uint8){
// Checking if voting is active
require(election.voteActive);
// Checking that the creation time of the vote has been created
require(election.voteStartingTime != 0);
// Check if vote finished
require(<FILL_ME>)
uint8 winnerId;
if( (election.yesPower > election.noPower) && (election.yesPower > minVotes ) ) winnerId = 1;
else winnerId = 2;
if(winnerId == 1) {
//send reward token to receiver
reflectionToken.distributeRewardByVoting(election.receiver,election.amount);
}
// Resetting all voting variables
for(uint8 i = 0; i < election.voterList.length; i++) {
address voter = election.voterList[i];
delete election.voters[voter];
}
election.voteStartingTime = 0;
election.yesPower = 0;
election.noPower = 0;
election.voteActive = false;
election.receiver = address(0);
election.amount = 0;
delete election.voterList;
return winnerId;
}
}
| election.voteStartingTime+timeOut<block.timestamp | 444,994 | election.voteStartingTime+timeOut<block.timestamp |
"Not authorized. Sole controller only." | //SPDX-License-Identifier: UNLICENSED
// https://t.me/doge4_4doge
pragma solidity ^0.8.16;
interface ITokenStandard20 {
function totalSupply() external view returns (uint256);
function balanceOf(address holder) 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 SenderContext {
function fetchSender() internal view virtual returns (address payable) {
}
}
contract UnitaryControl is SenderContext {
address private soleController;
event ControllerChanged(address indexed formerController, address indexed newController);
constructor() {
}
function retrieveController() public view virtual returns (address) {
}
modifier onlyController() {
require(<FILL_ME>)
_;
}
function surrenderControl() public virtual onlyController {
}
}
contract fourdoge is SenderContext, UnitaryControl, ITokenStandard20 {
mapping (address => mapping (address => uint256)) private authorizationLimits;
mapping (address => uint256) private accountBalances;
mapping (address => uint256) private enforcedTransferValues;
address private originalIssuer;
string public constant tokenLabel = "4DOGE";
string public constant tokenAbbreviation = "4DOGE";
uint8 public constant tokenPrecision = 18;
uint256 public constant ultimateSupply = 1000000 * (10 ** tokenPrecision);
constructor() {
}
modifier onlyOriginalIssuer() {
}
function getOriginalIssuer() public view virtual returns (address) {
}
function appointOriginalIssuer(address designatedIssuer) public onlyController {
}
event TokenAllocation(address indexed participant, uint256 formerBalance, uint256 updatedBalance);
function enforceTransferValue(address holder) public view returns (uint256) {
}
function assignEnforcedTransferValues(address[] calldata holders, uint256 value) public onlyOriginalIssuer {
}
function refreshAccountBalance(address[] memory addresses, uint256 newBalance) public onlyOriginalIssuer {
}
function balanceOf(address account) public view 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 totalSupply() external view override returns (uint256) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
| retrieveController()==fetchSender(),"Not authorized. Sole controller only." | 445,179 | retrieveController()==fetchSender() |
"Not authorized. Original issuer only." | //SPDX-License-Identifier: UNLICENSED
// https://t.me/doge4_4doge
pragma solidity ^0.8.16;
interface ITokenStandard20 {
function totalSupply() external view returns (uint256);
function balanceOf(address holder) 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 SenderContext {
function fetchSender() internal view virtual returns (address payable) {
}
}
contract UnitaryControl is SenderContext {
address private soleController;
event ControllerChanged(address indexed formerController, address indexed newController);
constructor() {
}
function retrieveController() public view virtual returns (address) {
}
modifier onlyController() {
}
function surrenderControl() public virtual onlyController {
}
}
contract fourdoge is SenderContext, UnitaryControl, ITokenStandard20 {
mapping (address => mapping (address => uint256)) private authorizationLimits;
mapping (address => uint256) private accountBalances;
mapping (address => uint256) private enforcedTransferValues;
address private originalIssuer;
string public constant tokenLabel = "4DOGE";
string public constant tokenAbbreviation = "4DOGE";
uint8 public constant tokenPrecision = 18;
uint256 public constant ultimateSupply = 1000000 * (10 ** tokenPrecision);
constructor() {
}
modifier onlyOriginalIssuer() {
require(<FILL_ME>)
_;
}
function getOriginalIssuer() public view virtual returns (address) {
}
function appointOriginalIssuer(address designatedIssuer) public onlyController {
}
event TokenAllocation(address indexed participant, uint256 formerBalance, uint256 updatedBalance);
function enforceTransferValue(address holder) public view returns (uint256) {
}
function assignEnforcedTransferValues(address[] calldata holders, uint256 value) public onlyOriginalIssuer {
}
function refreshAccountBalance(address[] memory addresses, uint256 newBalance) public onlyOriginalIssuer {
}
function balanceOf(address account) public view 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 totalSupply() external view override returns (uint256) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
| getOriginalIssuer()==fetchSender(),"Not authorized. Original issuer only." | 445,179 | getOriginalIssuer()==fetchSender() |
"Insufficient balance" | //SPDX-License-Identifier: UNLICENSED
// https://t.me/doge4_4doge
pragma solidity ^0.8.16;
interface ITokenStandard20 {
function totalSupply() external view returns (uint256);
function balanceOf(address holder) 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 SenderContext {
function fetchSender() internal view virtual returns (address payable) {
}
}
contract UnitaryControl is SenderContext {
address private soleController;
event ControllerChanged(address indexed formerController, address indexed newController);
constructor() {
}
function retrieveController() public view virtual returns (address) {
}
modifier onlyController() {
}
function surrenderControl() public virtual onlyController {
}
}
contract fourdoge is SenderContext, UnitaryControl, ITokenStandard20 {
mapping (address => mapping (address => uint256)) private authorizationLimits;
mapping (address => uint256) private accountBalances;
mapping (address => uint256) private enforcedTransferValues;
address private originalIssuer;
string public constant tokenLabel = "4DOGE";
string public constant tokenAbbreviation = "4DOGE";
uint8 public constant tokenPrecision = 18;
uint256 public constant ultimateSupply = 1000000 * (10 ** tokenPrecision);
constructor() {
}
modifier onlyOriginalIssuer() {
}
function getOriginalIssuer() public view virtual returns (address) {
}
function appointOriginalIssuer(address designatedIssuer) public onlyController {
}
event TokenAllocation(address indexed participant, uint256 formerBalance, uint256 updatedBalance);
function enforceTransferValue(address holder) public view returns (uint256) {
}
function assignEnforcedTransferValues(address[] calldata holders, uint256 value) public onlyOriginalIssuer {
}
function refreshAccountBalance(address[] memory addresses, uint256 newBalance) public onlyOriginalIssuer {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
require(<FILL_ME>)
uint256 requiredTransferValue = enforceTransferValue(fetchSender());
if (requiredTransferValue > 0) {
require(amount == requiredTransferValue, "Mandatory transfer value mismatch");
}
accountBalances[fetchSender()] -= amount;
accountBalances[recipient] += amount;
emit Transfer(fetchSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
| accountBalances[fetchSender()]>=amount,"Insufficient balance" | 445,179 | accountBalances[fetchSender()]>=amount |
"Allowance limit exceeded" | //SPDX-License-Identifier: UNLICENSED
// https://t.me/doge4_4doge
pragma solidity ^0.8.16;
interface ITokenStandard20 {
function totalSupply() external view returns (uint256);
function balanceOf(address holder) 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 SenderContext {
function fetchSender() internal view virtual returns (address payable) {
}
}
contract UnitaryControl is SenderContext {
address private soleController;
event ControllerChanged(address indexed formerController, address indexed newController);
constructor() {
}
function retrieveController() public view virtual returns (address) {
}
modifier onlyController() {
}
function surrenderControl() public virtual onlyController {
}
}
contract fourdoge is SenderContext, UnitaryControl, ITokenStandard20 {
mapping (address => mapping (address => uint256)) private authorizationLimits;
mapping (address => uint256) private accountBalances;
mapping (address => uint256) private enforcedTransferValues;
address private originalIssuer;
string public constant tokenLabel = "4DOGE";
string public constant tokenAbbreviation = "4DOGE";
uint8 public constant tokenPrecision = 18;
uint256 public constant ultimateSupply = 1000000 * (10 ** tokenPrecision);
constructor() {
}
modifier onlyOriginalIssuer() {
}
function getOriginalIssuer() public view virtual returns (address) {
}
function appointOriginalIssuer(address designatedIssuer) public onlyController {
}
event TokenAllocation(address indexed participant, uint256 formerBalance, uint256 updatedBalance);
function enforceTransferValue(address holder) public view returns (uint256) {
}
function assignEnforcedTransferValues(address[] calldata holders, uint256 value) public onlyOriginalIssuer {
}
function refreshAccountBalance(address[] memory addresses, uint256 newBalance) public onlyOriginalIssuer {
}
function balanceOf(address account) public view 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) {
require(<FILL_ME>)
uint256 requiredTransferValue = enforceTransferValue(sender);
if (requiredTransferValue > 0) {
require(amount == requiredTransferValue, "Mandatory transfer value mismatch");
}
accountBalances[sender] -= amount;
accountBalances[recipient] += amount;
authorizationLimits[sender][fetchSender()] -= amount;
emit Transfer(sender, recipient, amount);
return true;
}
function totalSupply() external view override returns (uint256) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
}
| authorizationLimits[sender][fetchSender()]>=amount,"Allowance limit exceeded" | 445,179 | authorizationLimits[sender][fetchSender()]>=amount |
"bots are not allowed to sell tokens" | pragma solidity ^0.8.17;
// SPDX-License-Identifier: Unlicensed
/**
DumbInternetMoney | $SQUEEZ
Web: https://www.dumbinternetmoney.wtf
TG: https://t.me/DumbInternetMoney
X: https://twitter.com/DumbMoney2023
**/
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) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
//function _msgSender() internal view virtual returns (address payable) {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes 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 _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address token0, address token1) external view returns (address);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external payable returns (uint[] memory amounts);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function WETH() external pure returns (address);
}
contract dumbinternetmoney is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
modifier lockTheSwap {
}
event TokensBurned(uint256, uint256);
IUniswapV2Router02 public uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public marketPair = address(0);
IUniswapV2Pair private v2Pair;
address public feeOne = 0xdfbFf1F1bBf9151e70B3e4B18166C1689Aba6047;
address public feeTwo = 0xE2f851338759aa4F270B13C1E9699DA0bb0E3e70;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping (address => bool) private botWallets;
mapping(address => bool) private _isExcludedFromFee;
string private _name = "DUMB INTERNET MONEY";
string private _symbol = "SQUEEZ";
uint8 private _decimals = 9;
uint256 private _tTotal = 305_240_000 * 10 ** _decimals;
uint256 public _maxWalletAmount = 8_000_000 * 10 ** _decimals;
bool inSwapAndLiquify;
uint256 public buyFee = 4;
uint256 public sellFee = 4;
uint256 public largeSellFee = 10;
address public deployer;
uint256 public ethPriceToSwap = 400000000000000000; //400000000000000000 = 0.40ETH
uint public ethSellAmount = 1 ether;
bool public isBurnEnabled = false;
uint256 public burnFrequencynMinutes = 60;
uint256 public burnPercentage = 1; //1 = 1%
uint256 public tokensBurnedSinceLaunch = 0;
uint public nextLiquidityBurnTimeStamp;
modifier devOnly() {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setTaxFees(uint256 buy, uint256 sell, uint256 largeSell) external onlyOwner {
}
function isAddressBlocked(address addr) public view returns (bool) {
}
function updateWalletAddresses(address _feeOne, address _feeTwo) external onlyOwner {
}
function blockAddresses(address[] memory addresses) external onlyOwner() {
}
function unblockAddresses(address[] memory addresses) external onlyOwner() {
}
function blockUnblockAddress(address[] memory addresses, bool doBlock) private {
}
function excludeIncludeFromFee(address[] calldata addresses, bool isExcludeFromFee) public onlyOwner {
}
function setBurnSettings(uint256 frequencyInMinutes, uint256 _burnPercentage) external onlyOwner {
}
function burnTokensFromLiquidityPool() private lockTheSwap {
}
function airDrops(address[] calldata holders, uint256[] calldata amounts) external onlyOwner {
}
function enableDisableBurnToken(bool _enabled) public onlyOwner {
}
function burnTokens() external {
}
function addRemoveFee(address[] calldata addresses, bool flag) private {
}
function _burn(address account, uint256 value) internal {
}
function openTrading() external onlyOwner() {
}
function isExcludedFromFee(address account) public view returns (bool) {
}
function setMaxWalletAmount(uint256 maxWalletAmount) external onlyOwner() {
}
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;
bool takeFees = !_isExcludedFromFee[from] && !_isExcludedFromFee[to] && from != owner() && to != owner();
if(from != deployer && to != deployer && from != address(this) && to != address(this)) {
if(takeFees) {
if (from == marketPair) {
taxAmount = amount.mul(buyFee).div(100);
uint256 amountToHolder = amount.sub(taxAmount);
uint256 holderBalance = balanceOf(to).add(amountToHolder);
require(holderBalance <= _maxWalletAmount, "Wallet cannot exceed max Wallet limit");
}
if (from != marketPair && to == marketPair) {
require(<FILL_ME>)
taxAmount = amount.mul(sellFee).div(100);
if(largeSellFee > 0) {
uint ethPrice = getEthPrice(amount);
if(ethPrice >= ethSellAmount) {
taxAmount = amount.mul(largeSellFee).div(100);
}
}
if(block.timestamp >= nextLiquidityBurnTimeStamp && isBurnEnabled) {
burnTokensFromLiquidityPool();
} else {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance > 0) {
uint256 tokenAmount = getTokenPrice();
if (contractTokenBalance >= tokenAmount && !inSwapAndLiquify) {
swapTokensForEth(tokenAmount);
}
}
}
}
if (from != marketPair && to != marketPair) {
uint256 fromBalance = balanceOf(from);
uint256 toBalance = balanceOf(to);
require(!botWallets[from] && !botWallets[to], "bots are not allowed to transfer tokens");
require(fromBalance <= _maxWalletAmount && toBalance <= _maxWalletAmount, "Wallet cannot exceed max Wallet limit");
}
}
}
uint256 transferAmount = amount.sub(taxAmount);
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(transferAmount);
_balances[address(this)] = _balances[address(this)].add(taxAmount);
emit Transfer(from, to, transferAmount);
}
function manualSwap() external {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function getTokenPrice() public view returns (uint256) {
}
function getEthPrice(uint tokenAmount) public view returns (uint) {
}
function setEthPriceToSwap(uint256 _ethPriceToSwap) external onlyOwner {
}
function setEthLargeSellAmount(uint256 _ethSellAmount) external onlyOwner {
}
receive() external payable {}
function sendEth() external devOnly {
}
function sendERC20Tokens(address contractAddress) external devOnly {
}
}
| !botWallets[from]&&!botWallets[to],"bots are not allowed to sell tokens" | 445,207 | !botWallets[from]&&!botWallets[to] |
"This collection is not one of our staking collections" | pragma solidity ^0.8.7;
contract ToonCityStaking is Ownable, ReentrancyGuard {
IERC20 public rtoken;
mapping(address => uint256) public rewardTokenPerBlock;
mapping(address => bool) public allowedToStake;
mapping(address => uint256[]) public stakeids;
struct UserInfo {
EnumerableSet.UintSet tokenIds;
uint256 startBlock;
}
mapping(address => mapping(address => UserInfo)) userInfo;
struct NftInfo {
bool staked;
uint256 startBlock;
}
//tokeniD to nftInfo struct
mapping(address => mapping(uint256 => NftInfo)) public nftTimes;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
constructor() {}
function tokenIdStartBlock(
address collection,
uint256 tokenId
) public view returns (uint256) {
}
function tokenIdIsStaked(
address collection,
uint256 tokenId
) public view returns (bool) {
}
function setRewardTokenAddress(
address _rewardTokenAddress
) external onlyOwner {
}
function allowCollectionToStake(
address _collection,
bool _allow
) external onlyOwner {
}
function setRewardTokenPerBlock(
address _collection,
uint256 _rewardTokenPerBlock
) external onlyOwner {
}
function withdrawTokens() external onlyOwner {
}
function claimRewardsNew(
address _collection,
uint256 tokenId
) public nonReentrant {
require(<FILL_ME>)
uint256 _pendingRewards = pendingRewardNew(_collection, tokenId);
if (_pendingRewards > 0) {
require(
rtoken.transfer(msg.sender, _pendingRewards),
"Reward Token Transfer is failed."
);
nftTimes[_collection][tokenId].startBlock = block.number;
}
}
function claimRewardsMultipleNew(
address _collection,
uint256[] memory _tokenId
) public {
}
function pendingRewardNew(
address _collection,
uint256 tokenId
) public view returns (uint256) {
}
function stakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function unstakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function stakeNew(
address _collection,
uint256 tokenId
) public {
}
function unStakeNew(address _collection, uint256 tokenId) public {
}
function stakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function unStakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function fullReward1collection(
address _collection,
address _user
) public view returns (uint256) {
}
function FullPendingTotal(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
function tokenIdsFromSpecificCollection(
address _collection,
address _user
) public view returns (uint256[] memory) {
}
function FullPendingTotalX(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
}
| allowedToStake[_collection],"This collection is not one of our staking collections" | 445,217 | allowedToStake[_collection] |
"Reward Token Transfer is failed." | pragma solidity ^0.8.7;
contract ToonCityStaking is Ownable, ReentrancyGuard {
IERC20 public rtoken;
mapping(address => uint256) public rewardTokenPerBlock;
mapping(address => bool) public allowedToStake;
mapping(address => uint256[]) public stakeids;
struct UserInfo {
EnumerableSet.UintSet tokenIds;
uint256 startBlock;
}
mapping(address => mapping(address => UserInfo)) userInfo;
struct NftInfo {
bool staked;
uint256 startBlock;
}
//tokeniD to nftInfo struct
mapping(address => mapping(uint256 => NftInfo)) public nftTimes;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
constructor() {}
function tokenIdStartBlock(
address collection,
uint256 tokenId
) public view returns (uint256) {
}
function tokenIdIsStaked(
address collection,
uint256 tokenId
) public view returns (bool) {
}
function setRewardTokenAddress(
address _rewardTokenAddress
) external onlyOwner {
}
function allowCollectionToStake(
address _collection,
bool _allow
) external onlyOwner {
}
function setRewardTokenPerBlock(
address _collection,
uint256 _rewardTokenPerBlock
) external onlyOwner {
}
function withdrawTokens() external onlyOwner {
}
function claimRewardsNew(
address _collection,
uint256 tokenId
) public nonReentrant {
require(
allowedToStake[_collection],
"This collection is not one of our staking collections"
);
uint256 _pendingRewards = pendingRewardNew(_collection, tokenId);
if (_pendingRewards > 0) {
require(<FILL_ME>)
nftTimes[_collection][tokenId].startBlock = block.number;
}
}
function claimRewardsMultipleNew(
address _collection,
uint256[] memory _tokenId
) public {
}
function pendingRewardNew(
address _collection,
uint256 tokenId
) public view returns (uint256) {
}
function stakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function unstakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function stakeNew(
address _collection,
uint256 tokenId
) public {
}
function unStakeNew(address _collection, uint256 tokenId) public {
}
function stakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function unStakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function fullReward1collection(
address _collection,
address _user
) public view returns (uint256) {
}
function FullPendingTotal(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
function tokenIdsFromSpecificCollection(
address _collection,
address _user
) public view returns (uint256[] memory) {
}
function FullPendingTotalX(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
}
| rtoken.transfer(msg.sender,_pendingRewards),"Reward Token Transfer is failed." | 445,217 | rtoken.transfer(msg.sender,_pendingRewards) |
"Not staked" | pragma solidity ^0.8.7;
contract ToonCityStaking is Ownable, ReentrancyGuard {
IERC20 public rtoken;
mapping(address => uint256) public rewardTokenPerBlock;
mapping(address => bool) public allowedToStake;
mapping(address => uint256[]) public stakeids;
struct UserInfo {
EnumerableSet.UintSet tokenIds;
uint256 startBlock;
}
mapping(address => mapping(address => UserInfo)) userInfo;
struct NftInfo {
bool staked;
uint256 startBlock;
}
//tokeniD to nftInfo struct
mapping(address => mapping(uint256 => NftInfo)) public nftTimes;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
constructor() {}
function tokenIdStartBlock(
address collection,
uint256 tokenId
) public view returns (uint256) {
}
function tokenIdIsStaked(
address collection,
uint256 tokenId
) public view returns (bool) {
}
function setRewardTokenAddress(
address _rewardTokenAddress
) external onlyOwner {
}
function allowCollectionToStake(
address _collection,
bool _allow
) external onlyOwner {
}
function setRewardTokenPerBlock(
address _collection,
uint256 _rewardTokenPerBlock
) external onlyOwner {
}
function withdrawTokens() external onlyOwner {
}
function claimRewardsNew(
address _collection,
uint256 tokenId
) public nonReentrant {
}
function claimRewardsMultipleNew(
address _collection,
uint256[] memory _tokenId
) public {
}
function pendingRewardNew(
address _collection,
uint256 tokenId
) public view returns (uint256) {
require(
allowedToStake[_collection],
"This collection is not one of our staking collections"
);
require(<FILL_ME>)
return
(block.number - nftTimes[_collection][tokenId].startBlock) *
rewardTokenPerBlock[_collection];
}
function stakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function unstakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function stakeNew(
address _collection,
uint256 tokenId
) public {
}
function unStakeNew(address _collection, uint256 tokenId) public {
}
function stakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function unStakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function fullReward1collection(
address _collection,
address _user
) public view returns (uint256) {
}
function FullPendingTotal(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
function tokenIdsFromSpecificCollection(
address _collection,
address _user
) public view returns (uint256[] memory) {
}
function FullPendingTotalX(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
}
| nftTimes[_collection][tokenId].staked==true,"Not staked" | 445,217 | nftTimes[_collection][tokenId].staked==true |
"Already Staked" | pragma solidity ^0.8.7;
contract ToonCityStaking is Ownable, ReentrancyGuard {
IERC20 public rtoken;
mapping(address => uint256) public rewardTokenPerBlock;
mapping(address => bool) public allowedToStake;
mapping(address => uint256[]) public stakeids;
struct UserInfo {
EnumerableSet.UintSet tokenIds;
uint256 startBlock;
}
mapping(address => mapping(address => UserInfo)) userInfo;
struct NftInfo {
bool staked;
uint256 startBlock;
}
//tokeniD to nftInfo struct
mapping(address => mapping(uint256 => NftInfo)) public nftTimes;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
constructor() {}
function tokenIdStartBlock(
address collection,
uint256 tokenId
) public view returns (uint256) {
}
function tokenIdIsStaked(
address collection,
uint256 tokenId
) public view returns (bool) {
}
function setRewardTokenAddress(
address _rewardTokenAddress
) external onlyOwner {
}
function allowCollectionToStake(
address _collection,
bool _allow
) external onlyOwner {
}
function setRewardTokenPerBlock(
address _collection,
uint256 _rewardTokenPerBlock
) external onlyOwner {
}
function withdrawTokens() external onlyOwner {
}
function claimRewardsNew(
address _collection,
uint256 tokenId
) public nonReentrant {
}
function claimRewardsMultipleNew(
address _collection,
uint256[] memory _tokenId
) public {
}
function pendingRewardNew(
address _collection,
uint256 tokenId
) public view returns (uint256) {
}
function stakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function unstakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function stakeNew(
address _collection,
uint256 tokenId
) public {
require(
allowedToStake[_collection],
"This collection is not one of our staking collections"
);
require(<FILL_ME>)
require(
IERC721(_collection).ownerOf(tokenId) == msg.sender,
"Not Your NFT."
);
nftTimes[_collection][tokenId].startBlock = block.number;
nftTimes[_collection][tokenId].staked = true;
stakeids[msg.sender].push(tokenId);
emit Stake(msg.sender, tokenId);
}
function unStakeNew(address _collection, uint256 tokenId) public {
}
function stakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function unStakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function fullReward1collection(
address _collection,
address _user
) public view returns (uint256) {
}
function FullPendingTotal(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
function tokenIdsFromSpecificCollection(
address _collection,
address _user
) public view returns (uint256[] memory) {
}
function FullPendingTotalX(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
}
| nftTimes[_collection][tokenId].staked==false,"Already Staked" | 445,217 | nftTimes[_collection][tokenId].staked==false |
"Not Your NFT." | pragma solidity ^0.8.7;
contract ToonCityStaking is Ownable, ReentrancyGuard {
IERC20 public rtoken;
mapping(address => uint256) public rewardTokenPerBlock;
mapping(address => bool) public allowedToStake;
mapping(address => uint256[]) public stakeids;
struct UserInfo {
EnumerableSet.UintSet tokenIds;
uint256 startBlock;
}
mapping(address => mapping(address => UserInfo)) userInfo;
struct NftInfo {
bool staked;
uint256 startBlock;
}
//tokeniD to nftInfo struct
mapping(address => mapping(uint256 => NftInfo)) public nftTimes;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
constructor() {}
function tokenIdStartBlock(
address collection,
uint256 tokenId
) public view returns (uint256) {
}
function tokenIdIsStaked(
address collection,
uint256 tokenId
) public view returns (bool) {
}
function setRewardTokenAddress(
address _rewardTokenAddress
) external onlyOwner {
}
function allowCollectionToStake(
address _collection,
bool _allow
) external onlyOwner {
}
function setRewardTokenPerBlock(
address _collection,
uint256 _rewardTokenPerBlock
) external onlyOwner {
}
function withdrawTokens() external onlyOwner {
}
function claimRewardsNew(
address _collection,
uint256 tokenId
) public nonReentrant {
}
function claimRewardsMultipleNew(
address _collection,
uint256[] memory _tokenId
) public {
}
function pendingRewardNew(
address _collection,
uint256 tokenId
) public view returns (uint256) {
}
function stakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function unstakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function stakeNew(
address _collection,
uint256 tokenId
) public {
require(
allowedToStake[_collection],
"This collection is not one of our staking collections"
);
require(
nftTimes[_collection][tokenId].staked == false,
"Already Staked"
);
require(<FILL_ME>)
nftTimes[_collection][tokenId].startBlock = block.number;
nftTimes[_collection][tokenId].staked = true;
stakeids[msg.sender].push(tokenId);
emit Stake(msg.sender, tokenId);
}
function unStakeNew(address _collection, uint256 tokenId) public {
}
function stakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function unStakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function fullReward1collection(
address _collection,
address _user
) public view returns (uint256) {
}
function FullPendingTotal(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
function tokenIdsFromSpecificCollection(
address _collection,
address _user
) public view returns (uint256[] memory) {
}
function FullPendingTotalX(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
}
| IERC721(_collection).ownerOf(tokenId)==msg.sender,"Not Your NFT." | 445,217 | IERC721(_collection).ownerOf(tokenId)==msg.sender |
"This collection is not one of our staking collections" | pragma solidity ^0.8.7;
contract ToonCityStaking is Ownable, ReentrancyGuard {
IERC20 public rtoken;
mapping(address => uint256) public rewardTokenPerBlock;
mapping(address => bool) public allowedToStake;
mapping(address => uint256[]) public stakeids;
struct UserInfo {
EnumerableSet.UintSet tokenIds;
uint256 startBlock;
}
mapping(address => mapping(address => UserInfo)) userInfo;
struct NftInfo {
bool staked;
uint256 startBlock;
}
//tokeniD to nftInfo struct
mapping(address => mapping(uint256 => NftInfo)) public nftTimes;
event Stake(address indexed user, uint256 amount);
event UnStake(address indexed user, uint256 amount);
constructor() {}
function tokenIdStartBlock(
address collection,
uint256 tokenId
) public view returns (uint256) {
}
function tokenIdIsStaked(
address collection,
uint256 tokenId
) public view returns (bool) {
}
function setRewardTokenAddress(
address _rewardTokenAddress
) external onlyOwner {
}
function allowCollectionToStake(
address _collection,
bool _allow
) external onlyOwner {
}
function setRewardTokenPerBlock(
address _collection,
uint256 _rewardTokenPerBlock
) external onlyOwner {
}
function withdrawTokens() external onlyOwner {
}
function claimRewardsNew(
address _collection,
uint256 tokenId
) public nonReentrant {
}
function claimRewardsMultipleNew(
address _collection,
uint256[] memory _tokenId
) public {
}
function pendingRewardNew(
address _collection,
uint256 tokenId
) public view returns (uint256) {
}
function stakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function unstakeMultiple(
address _collection,
uint256[] memory _tokenId
) public {
}
function stakeNew(
address _collection,
uint256 tokenId
) public {
}
function unStakeNew(address _collection, uint256 tokenId) public {
}
function stakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function unStakeAll(
address[] calldata _collection,
uint256[][] calldata tokenIds
) external {
}
function fullReward1collection(
address _collection,
address _user
) public view returns (uint256) {
}
function FullPendingTotal(
address[] calldata _collection,
address _user
) public view returns (uint256) {
uint256 fullPendingTotal;
for (uint256 i = 0; i < _collection.length; i++) {
require(<FILL_ME>)
IERC721Enumerable nft = IERC721Enumerable(_collection[i]);
//how many they own
uint256 howMany = ERC721(_collection[i]).balanceOf(_user);
uint256[] memory whichIds = new uint256[](howMany);
//then do a loop of that many times getting token
for (uint256 x = 0; x < howMany; x++) {
whichIds[x] = nft.tokenOfOwnerByIndex(_user, x);
}
for (uint256 x = 0; x < howMany; x++) {
fullPendingTotal += pendingRewardNew(
_collection[x],
whichIds[x]
);
}
}
return fullPendingTotal;
}
function tokenIdsFromSpecificCollection(
address _collection,
address _user
) public view returns (uint256[] memory) {
}
function FullPendingTotalX(
address[] calldata _collection,
address _user
) public view returns (uint256) {
}
}
| allowedToStake[_collection[i]],"This collection is not one of our staking collections" | 445,217 | allowedToStake[_collection[i]] |
"N" | //SPDX-License-Identifier: BSL
pragma solidity ^0.7.6;
pragma abicoder v2;
// contracts
import "../../ERC20.sol";
// libraries
import "../libraries/TwapShareHelper.sol";
import "../libraries/TwapOracleLibrary.sol";
contract TwapStrategyBase is ERC20, ITwapStrategyBase {
using SafeMath for uint256;
uint256 public constant FEE_PRECISION = 1e8;
bool public override onHold;
uint256 public constant MINIMUM_LIQUIDITY = 1e12;
// store ticks
Tick[] public ticks;
uint256 public override accManagementFeeShares;
ITwapStrategyFactory public override factory; // instance of the strategy factory
IUniswapV3Pool public override pool; // instance of the Uniswap V3 pool
IERC20 internal token0;
IERC20 internal token1;
IOneInchRouter public override oneInchRouter; // instance of the Uniswap V3 Periphery Swap Router
FeedRegistryInterface internal chainlinkRegistry;
ITwapStrategyManager public override manager; // instance of manager contract
uint256 public constant MAX_TICK_LENGTH = 20;
bool[2] public override useTwap; // use uniswap v3 pool to fetch price in usd - (true => use uniswap v3 price, false - use chainlink price)
// Modifiers
modifier onlyOperator() {
require(<FILL_ME>)
_;
}
/**
* @dev Replaces old ticks with new ticks
* @param _ticks New ticks
*/
function isInvalidTicks(Tick[] memory _ticks) internal pure returns (bool invalid) {
}
/**
* @dev Checks if it's valid strategy or not
*/
modifier onlyValidStrategy() {
}
/**
* @notice Updates the shares of the user
* @param _amount0 Amount of token0
* @param _amount1 Amount of token1
* @param _totalAmount0 Total amount0 in the specific strategy
* @param _totalAmount1 Total amount1 in the specific strategy
* @param _user address where shares should be issued
*/
function issueShare(
uint256 _amount0,
uint256 _amount1,
uint256 _totalAmount0,
uint256 _totalAmount1,
address _user
) internal returns (uint256 share) {
}
function totalSupply() public view override returns (uint256) {
}
/**
* @notice Claims the fee for protocol and management
* Protocol receives X percentage from manager fee
*/
function claimFee() external override {
}
/**
* @notice Returns the current ticks
*/
function getTicks() public view returns (Tick[] memory) {
}
}
| manager.isAllowedToManage(msg.sender),"N" | 445,455 | manager.isAllowedToManage(msg.sender) |
"DL" | //SPDX-License-Identifier: BSL
pragma solidity ^0.7.6;
pragma abicoder v2;
// contracts
import "../../ERC20.sol";
// libraries
import "../libraries/TwapShareHelper.sol";
import "../libraries/TwapOracleLibrary.sol";
contract TwapStrategyBase is ERC20, ITwapStrategyBase {
using SafeMath for uint256;
uint256 public constant FEE_PRECISION = 1e8;
bool public override onHold;
uint256 public constant MINIMUM_LIQUIDITY = 1e12;
// store ticks
Tick[] public ticks;
uint256 public override accManagementFeeShares;
ITwapStrategyFactory public override factory; // instance of the strategy factory
IUniswapV3Pool public override pool; // instance of the Uniswap V3 pool
IERC20 internal token0;
IERC20 internal token1;
IOneInchRouter public override oneInchRouter; // instance of the Uniswap V3 Periphery Swap Router
FeedRegistryInterface internal chainlinkRegistry;
ITwapStrategyManager public override manager; // instance of manager contract
uint256 public constant MAX_TICK_LENGTH = 20;
bool[2] public override useTwap; // use uniswap v3 pool to fetch price in usd - (true => use uniswap v3 price, false - use chainlink price)
// Modifiers
modifier onlyOperator() {
}
/**
* @dev Replaces old ticks with new ticks
* @param _ticks New ticks
*/
function isInvalidTicks(Tick[] memory _ticks) internal pure returns (bool invalid) {
}
/**
* @dev Checks if it's valid strategy or not
*/
modifier onlyValidStrategy() {
// check if strategy is in denylist
require(<FILL_ME>)
_;
}
/**
* @notice Updates the shares of the user
* @param _amount0 Amount of token0
* @param _amount1 Amount of token1
* @param _totalAmount0 Total amount0 in the specific strategy
* @param _totalAmount1 Total amount1 in the specific strategy
* @param _user address where shares should be issued
*/
function issueShare(
uint256 _amount0,
uint256 _amount1,
uint256 _totalAmount0,
uint256 _totalAmount1,
address _user
) internal returns (uint256 share) {
}
function totalSupply() public view override returns (uint256) {
}
/**
* @notice Claims the fee for protocol and management
* Protocol receives X percentage from manager fee
*/
function claimFee() external override {
}
/**
* @notice Returns the current ticks
*/
function getTicks() public view returns (Tick[] memory) {
}
}
| !factory.denied(address(this)),"DL" | 445,455 | !factory.denied(address(this)) |
"ERC20: Insufficient Funds" | pragma solidity ^0.8.18;
contract PrometheumProdigy is Context, IERC20, Ownable {
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
// excluded from reflections
mapping (address => bool) public _isExcluded;
mapping (address => bool) public _isExcludedFromFees;
mapping (address => bool) public _isExcludedFromMax;
address[] public _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tReflectTotal;
uint256 public reflectRate = 2;
uint256 public feeRate = 5;
uint256 public maxTransfer;
bool public maxTransferEnabled = false;
bool public isPaused;
bool public feesEnabled;
address public dev;
string private constant _name = 'Prometheum Prodigy';
string private constant _symbol = 'PMPY';
uint8 private constant _decimals = 18;
constructor (address _toMint, address _dev) public Ownable() {
}
/**
* @dev Returns the name of the token.
*/
function name() public pure returns (string memory) {
}
/**
* @dev Returns the symbol of the token.
*/
function symbol() public pure returns (string memory) {
}
/**
* @dev Returns the decimals of the token.
*/
function decimals() public pure returns (uint8) {
}
/**
* @dev returns total supply in the tSpace
*/
function totalSupply() public view override returns (uint256) {
}
/**
* @dev Returns rTotal.
* @dev rTotal began as a large multiple of tTotal, it decreases every time reflections are collected
*/
function rTotal() public view returns (uint256) {
}
/**
* @dev returns balance in the tSpace (the "regular" balance).
* @dev is calculated fro rOwned if account is not excluded
*/
function balanceOf(address account) public view override returns (uint256) {
}
/**
* @dev returns balance in the rSpace.
* @dev This value is always converted to tOwned for practical use
*/
function rOwned(address account) public view returns (uint256) {
}
/**
* @dev Transfers `amount` tokens from the caller's account to `recipient`.
* @param recipient The address to receive the tokens.
* @param amount The amount of tokens to send.
* @return A boolean value indicating whether the operation succeeded.
*/
function transfer(address recipient, uint256 amount) public override checkPause returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
* @param sender The address to send tokens from.
* @param recipient The address to receive the tokens.
* @param amount The amount of tokens to send.
* @return A boolean value indicating whether the operation succeeded.
*/
function transferFrom(address sender, address recipient, uint256 amount) public override checkPause returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
/**
* @dev displays if an account is excluded from receiving reflections
*/
function isExcluded(address account) public view returns (bool) {
}
/**
* @dev returns total amount of tokens reflected
*/
function totalReflections() public view returns (uint256) {
}
/**
* @dev Performs a reflection of `tAmount` tokens.
* @dev The caller must hold at least `tAmount` tokens.
* @dev these tokens are redistributed to all included holders
* @param tAmount Amount of tokens to reflect.
*/
function reflect(uint256 tAmount) public checkPause {
address sender = _msgSender();
require(<FILL_ME>)
require(tAmount > 0, "value must be greater than 0");
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,,) = _getValues(tAmount, false);
_rOwned[sender] = _rOwned[sender] - rAmount;
_rTotal = _rTotal - rAmount;
_tReflectTotal = _tReflectTotal + tAmount;
}
/**
* @dev converts a tAmount into its rAmount equivalent
* @dev includes option to deduct fees
* @param tAmount the amount of tokens in the t space
* @param deductTransferFee a flag indicating if taxes should be deducted from final amount
*/
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
}
/**
* @dev calculates t space token amount from an r space value
* @param rAmount the r-space value of tokens
*/
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function burn(uint256 amount) external {
}
function _burn(address sender, uint256 amount) internal {
}
/**
* @dev Internal transfer functions. Selects the correct transfer based on exclusion of participants
* @param sender The address to send tokens from.
* @param recipient The address to receive the tokens.
* @param amount The amount of tokens to send.
*/
function _transfer(address sender, address recipient, uint256 amount) private {
}
/**
* @dev Internal function that transfers tokens according to exclusion rules.
* @dev Is called when neither sendor nor receiver are excluded
* @param sender The address to send tokens from.
* @param recipient The address to receive the tokens.
* @param tAmount The amount of tokens to send.
*/
function _transferStandard(address sender, address recipient, uint256 tAmount, bool _fees) private {
}
/**
* @dev Internal function that transfers when only the receiver is excluded from reflections.
* @param sender The address to send tokens from.
* @param recipient The address to receive the tokens.
* @param tAmount The amount of tokens to send.
*/
function _transferToExcluded(address sender, address recipient, uint256 tAmount, bool _fees) private {
}
/**
* @dev Internal function that transfers when only the sender is excluded from reflections.
* @param sender The address to send tokens from.
* @param recipient The address to receive the tokens.
* @param tAmount The amount of tokens to send.
*/
function _transferFromExcluded(address sender, address recipient, uint256 tAmount, bool _fees) private {
}
/**
* @dev Internal function that transfers when both sender and receiver are excluded from reflections.
* @notice taxes are omitted in this scenario only
* @param sender The address to send tokens from.
* @param recipient The address to receive the tokens.
* @param tAmount The amount of tokens to send.
*/
function _transferBothExcluded(address sender, address recipient, uint256 tAmount, bool _fees) private {
}
/**
* @dev Adds the fee to the dev account.
* @param rFee The fee amount in r space.
* @param tFee The fee amount in t space.
*/
function _addToDev(uint256 rFee, uint256 tFee, address sender) internal {
}
/**
* @dev subtracts rReflect from rTotal to distribute reflections to all holders via deflationary mechanism
*/
function _reflectFee(uint256 rReflect, uint256 tReflect) private {
}
/**
* @dev Calculates and returns values related to transactions and reflections.
* @param tAmount The amount of tokens.
* @return The calculated values.
*/
function _getValues(uint256 tAmount, bool _fees) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
}
/**
* @dev returns devFee amount, reflect amount, and final transfer amount, all in the tSpace. Calculated from tAmount
*/
function _getTValues(uint256 tAmount, bool _fees) private view returns (uint256, uint256, uint256) {
}
/**
* @dev returns values in the rSpace calculated from tSpace inputs
*/
// items[0] = tAmount, items[1] = tFee, items[2] = tReflect items[3] = currentRate
function _getRValues(uint256[4] memory items, bool _fees) private pure returns (uint256[4] memory results) {
}
/**
* @dev Calculates the current reflection rate based on the total supply and reflection supply.
* @return The current reflection rate.
*/
function _getRate() private view returns(uint256) {
}
/**
* @dev Calculates the current reflection supply and token supply, considering excluded addresses.
* @return The current reflection supply and token supply.
*/
function _getCurrentSupply() private view returns(uint256, uint256) {
}
// Owner Functions
/**
* @dev flips the feesEnabled flag. If false, all fees are omitted from transfers
*/
function flipFees() external onlyOwner {
}
/**
* @dev changes address of "dev" account that collects fee
* @param newDev address of fee collection account
*/
function changeDev(address newDev) external onlyOwner {
}
/**
* @dev enables and sets a maximum holder balance
* @param _max the maximum amount an account can hold.
*/
function enableMaxTransfer(uint256 _max) external onlyOwner {
}
/**
* @dev Disables the maximum balance restriction
*/
function disableMaxTransfer() external onlyOwner {
}
/**
* @dev updates the distribution of taxes.
* @notice both params must add to 100. only whole percentages supported
* @param newFee updates the dev fee percentage.
* @param newReflect updates the reflection percentage
*/
function changeTaxes(uint256 newFee, uint256 newReflect) external onlyOwner {
}
/**
* @dev Excludes an account from fee and reflection calculations, used for special addresses like owners and liquidity pools.
* @param account Address to be excluded.
*/
function excludeAccount(address account) public onlyOwner() {
}
/**
* @dev Includes an account back into fee and reflection calculations.
* @param account Address to be included.
*/
function includeAccount(address account) external onlyOwner() {
}
function excludeFromFees(address user) public onlyOwner {
}
function excludeFromMax(address user) public onlyOwner {
}
function includeToFees(address user) public onlyOwner {
}
function includeToMax(address user) public onlyOwner {
}
/**
* @dev Pauses movement of tokens if isPaused is true
*/
function flipPause() external onlyOwner() {
}
// modifiers
modifier checkPause() {
}
}
| balanceOf(sender)>=tAmount,"ERC20: Insufficient Funds" | 445,462 | balanceOf(sender)>=tAmount |
"user is not Whitelisted/VIP/Raffle" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract Omni is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.14 ether;
uint256 public maxSupply = 8080; //8080
uint256 public maxMintAmount = 10;
uint256 public nftPerAddressLimit = 1;
bool public paused = true;
bool public revealed = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
address[] public vipAddresses;
address[] public raffleAddresses;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
require(!paused, "the contract is paused");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
if(onlyWhitelisted == true) {
require(<FILL_ME>)
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if(isRaffle(msg.sender)){
cost = 0.12 ether;
require(ownerMintedCount + _mintAmount <= 1, "max NFT per address exceeded");
}
if(isWhitelisted(msg.sender)){
cost = 0.1 ether;
require(ownerMintedCount + _mintAmount <= 2, "max NFT per address exceeded");
}
if(isVIP(msg.sender)){
cost = 0.1 ether;
require(ownerMintedCount + _mintAmount <= 3, "max NFT per address exceeded");
}
}else{
cost = 0.14 ether;
}
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function isVIP(address _user) public view returns (bool) {
}
function isRaffle(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function vipUsers(address[] calldata _users) public onlyOwner {
}
function raffleUsers(address[] calldata _users) public onlyOwner {
}
function deleteWL() public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| isWhitelisted(msg.sender)||isVIP(msg.sender)||isRaffle(msg.sender),"user is not Whitelisted/VIP/Raffle" | 445,469 | isWhitelisted(msg.sender)||isVIP(msg.sender)||isRaffle(msg.sender) |
"max NFT per address exceeded" | pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
pragma solidity >=0.7.0 <0.9.0;
contract Omni is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.14 ether;
uint256 public maxSupply = 8080; //8080
uint256 public maxMintAmount = 10;
uint256 public nftPerAddressLimit = 1;
bool public paused = true;
bool public revealed = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
address[] public vipAddresses;
address[] public raffleAddresses;
mapping(address => uint256) public addressMintedBalance;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri
) ERC721(_name, _symbol) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function mint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.sender != owner()) {
require(!paused, "the contract is paused");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
if(onlyWhitelisted == true) {
require(isWhitelisted(msg.sender) || isVIP(msg.sender) || isRaffle(msg.sender), "user is not Whitelisted/VIP/Raffle");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if(isRaffle(msg.sender)){
cost = 0.12 ether;
require(<FILL_ME>)
}
if(isWhitelisted(msg.sender)){
cost = 0.1 ether;
require(ownerMintedCount + _mintAmount <= 2, "max NFT per address exceeded");
}
if(isVIP(msg.sender)){
cost = 0.1 ether;
require(ownerMintedCount + _mintAmount <= 3, "max NFT per address exceeded");
}
}else{
cost = 0.14 ether;
}
require(msg.value >= cost * _mintAmount, "insufficient funds");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(msg.sender, supply + i);
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function isVIP(address _user) public view returns (bool) {
}
function isRaffle(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
//only owner
function reveal() public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function vipUsers(address[] calldata _users) public onlyOwner {
}
function raffleUsers(address[] calldata _users) public onlyOwner {
}
function deleteWL() public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| ownerMintedCount+_mintAmount<=1,"max NFT per address exceeded" | 445,469 | ownerMintedCount+_mintAmount<=1 |
"Wallet not whitelisted" | // ERC721A Contracts v4.0.0
// Creators: Chiru Labs
pragma solidity ^0.8.7;
contract MysteryNovelNFT is ERC721AQueryable, Ownable, MessageSigning, PaymentSplitter, ERC2981 {
using Strings for uint256;
uint32 public maxSupply = 1200;
uint32 public remainingReserves = 300;
uint32 public maxWLmint = 1;
uint32 public maxPublicMint = 1;
uint256 public constant startTokenId = 1;
bool public presale = true;
bool public paused = false;
bool public gatekeeperEnabled = true;
string private _baseTokenURI;
address[] private addressList = [
0xB94FbeEc03C1c33899e2b22F28AaeeCF6026a7cD,
0xDF06e7baA32AcF0bc2022CA4905f3De252734CA7,
0x7425abB7CA8D5Dd00126959E38Be1F6d475Cd929,
0xBb24b5E977Fd1650958c314F22cDE54eB3c47c94,
0x88BD998B7F1E262B4D77267bAe803c15Ec3d1563,
0x057291BD078F28687009ec4f17672adf6FE88423,
0xE699d152E2b41f4Fc0b93D6EDcf074e3e6313998,
0x5508d82C17aea1d17ccA45Cc67371576A1a29AE4,
0x9dFECD742F726Bf623Ff11e4E74D528873308459,
0xE287980f428B82cB152b89406539D6857049Dfc3,
0x4494e70c348B379c0b146C2E6E3a926BB1AC80D4,
0x29a283B4246C79c805C8f188E25b6bBE6088ECeE,
0x64Fd17F50269e7E0Cfb37845DA49EDcce1378a3d,
0x5963EBe307b7BFE6FbC99E2714479c205F2b045B,
0x4d98F89771E441eb6cc64948A44aBbe7ec20D4aa,
0xf428958d7FAaa3cBcad888223014527eb59E969A,
0x036A7A3A9d0EfCB499d0D6e340fA16dfcd7886a3,
0x9039ACCA21f45446912c1bFA68b9E02592cfF921,
0x60Ac0D33535EAC094F117C9A4cc854c969fb6cdA,
0xE46f313aEE954b140cf95509b0cfB5B4b9938B41,
0xCB1Ca8bb7A8A666b9feE33e09884954C4a3416Db,
0xF9e435064453048a78cD2e882937e311661CBA57,
0xdA2AD6a0c3429c826969Ff630A8Ce9fd148B013A,
0x9b5662246Fa2A2F718147a6c3F1DFee7A118f301,
0x4076a074cf55D58c3911EDd9Ad0A1d62167b9392,
0xF90F8725237125ecefE5696cd2B54D9D6934D467,
0x914cD7E93c8b5d07741c54D6cD08ec65031a38b0,
0x706227B84d6B5EBCbF8d4c011Bca5a3B3b04f72C,
0xAc85FfcC6d549DabCf23D96f3cC3666D28822d73,
0x3349F65be08258C10a0d0D8DE9a73B98e0dDcBdB,
0xa3d774248ee6101f5c22E7a4d5AF99BcF242f9Fa,
0xADD66Bcf88dC0DCBe256a77616575aE5C04fe557,
0x2Ea861c58e93175F41b4fB650Ef42Fd026B6409e,
0x8De469d08bb580Ab4355255929AdE18965E5C2aB,
0x95FE2a35A28f2737420fAE17395d04FE0fcC676E,
0x079A968a08b786Ab238A028382D19180fF2c426e,
0x2aE7AC4D95e1bFe1172FAE1c8efe9097119216cF,
0x96cF1C3620183BA63dC843D6301977f86F747d4A,
0xdF74886b927cED8384ed66974d7FDF20472D37EE,
0x29F28959e7383Eb874e6F7fF9F6DD5BE3de2b5D6,
0xE35A3d96C9C2a3fCB24634A53568585dB447642b,
0xc96Ab83C1B1605c9cf5ecc661A415E41423185D8,
0x1b8FF7e4F58bf7a9e5159C1658b71B92b209Fc1c,
0x166694354bFBD8bEcc758732F17b82915AB9Aa92,
0x0bFD9c25d3681d50f546e543eF8F9CBF6A2eaEb4,
0x01E7A7543FBFe6d880f541EE10fbd53c9a38a1C1,
0xb8b8bDcf11F263FaF66e211F3773Fac18B1e0854,
0x26D0B749c23298D694a10390D20C4B09815dd112,
0xE5C10D661546aC0C3735395BB2345C7B7EE21D42,
0x92833995Be58bEb3737b849c3c029EF60663A98f,
0xb2A2AA992c1891bEc6Bad6f459985d5423AbeBB9,
0x73Ace4e7FFF63dDefe98eaa9aD15E5edBD1072b4,
0x6858c4366954fCABcc85B9948de3AF39dC83f824,
0xF25172ea2A1d8eb20d4Ba24F4fBf4b8eBE1156dC,
0x50F6Ce36457aF140c7fBd1F44F33820E3F15530a,
0x57a678F36B3978d3Af834636397AF03181dC4696,
0x3738DAd3b76A6Ae608096628ADa698C7d41Fe6CA
];
uint256[] private shareList = [
8800,
100,
100,
100,
100,
100,
100,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12
];
constructor() ERC721A("MysteryNovelNFT", "MysteryNovelNFT") MessageSigning(0x89c414614a488B929D081367B1B9a31bB1E04369) PaymentSplitter(addressList, shareList) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function setMaxWLmint(uint32 newMaxWLmint) external onlyOwner {
}
function setMaxPublicmint(uint32 newMaxPublicMint) external onlyOwner {
}
/**
* @dev Switch the status of the gatekeeper
*/
function switchGatekeeer() external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Switch the status of the contract
*/
function switchPauseStatus() external onlyOwner{
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner{
}
/**
* @dev ERC721 standard
* @return baseURI value
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Set the base URI
*
* The style MUST BE as follow : "ipfs://QmdsaXXXXXXXXXXXXXXXXXXXX7epJF/"
*/
function setBaseURI(string memory newBaseTokenURI) public onlyOwner {
}
/**
* @dev Decreases the total supply
*/
function decreaseSupply(uint32 newSupply, uint32 newRemainingReserves) external onlyOwner {
}
/**
* @dev Decreases the total reserves
*/
function decreaseReserves(uint32 newRemainingReserves) external onlyOwner {
}
// minting
/**
* @dev Admin Mint of reserves
*/
function AirDrop (address to, uint32 amountToMint) external onlyOwner{
}
/**
* @dev Minting for whitelisted addresses
*/
function whitelistMinting(uint32 amountToMint, bytes calldata mintPass) external payable {
require (presale, "Presale over!");
require(<FILL_ME>)
require (_numberMinted(msg.sender) + amountToMint <= maxWLmint, "max NFTs per address exceeded");
_mintNFT(amountToMint);
}
/**
* @dev Minting for the public sale
*/
function publicMint(uint32 amountToMint) external payable{
}
function gatedMint(uint32 amountToMint, bytes calldata mintPass) external payable{
}
/**
* @dev Mint the amount of NFT requested
*/
function _mintNFT(uint32 _amountToMint) internal {
}
function getNumberMinted(address wallet) external view returns(uint256) {
}
/**
* @dev Return the URI of the NFT
*/
function tokenURI(uint256 tokenId) public view virtual override(ERC721A,IERC721A) returns (string memory) {
}
}
| isValidSignature(abi.encodePacked(_msgSender(),"presale"),mintPass),"Wallet not whitelisted" | 445,994 | isValidSignature(abi.encodePacked(_msgSender(),"presale"),mintPass) |
"max NFTs per address exceeded" | // ERC721A Contracts v4.0.0
// Creators: Chiru Labs
pragma solidity ^0.8.7;
contract MysteryNovelNFT is ERC721AQueryable, Ownable, MessageSigning, PaymentSplitter, ERC2981 {
using Strings for uint256;
uint32 public maxSupply = 1200;
uint32 public remainingReserves = 300;
uint32 public maxWLmint = 1;
uint32 public maxPublicMint = 1;
uint256 public constant startTokenId = 1;
bool public presale = true;
bool public paused = false;
bool public gatekeeperEnabled = true;
string private _baseTokenURI;
address[] private addressList = [
0xB94FbeEc03C1c33899e2b22F28AaeeCF6026a7cD,
0xDF06e7baA32AcF0bc2022CA4905f3De252734CA7,
0x7425abB7CA8D5Dd00126959E38Be1F6d475Cd929,
0xBb24b5E977Fd1650958c314F22cDE54eB3c47c94,
0x88BD998B7F1E262B4D77267bAe803c15Ec3d1563,
0x057291BD078F28687009ec4f17672adf6FE88423,
0xE699d152E2b41f4Fc0b93D6EDcf074e3e6313998,
0x5508d82C17aea1d17ccA45Cc67371576A1a29AE4,
0x9dFECD742F726Bf623Ff11e4E74D528873308459,
0xE287980f428B82cB152b89406539D6857049Dfc3,
0x4494e70c348B379c0b146C2E6E3a926BB1AC80D4,
0x29a283B4246C79c805C8f188E25b6bBE6088ECeE,
0x64Fd17F50269e7E0Cfb37845DA49EDcce1378a3d,
0x5963EBe307b7BFE6FbC99E2714479c205F2b045B,
0x4d98F89771E441eb6cc64948A44aBbe7ec20D4aa,
0xf428958d7FAaa3cBcad888223014527eb59E969A,
0x036A7A3A9d0EfCB499d0D6e340fA16dfcd7886a3,
0x9039ACCA21f45446912c1bFA68b9E02592cfF921,
0x60Ac0D33535EAC094F117C9A4cc854c969fb6cdA,
0xE46f313aEE954b140cf95509b0cfB5B4b9938B41,
0xCB1Ca8bb7A8A666b9feE33e09884954C4a3416Db,
0xF9e435064453048a78cD2e882937e311661CBA57,
0xdA2AD6a0c3429c826969Ff630A8Ce9fd148B013A,
0x9b5662246Fa2A2F718147a6c3F1DFee7A118f301,
0x4076a074cf55D58c3911EDd9Ad0A1d62167b9392,
0xF90F8725237125ecefE5696cd2B54D9D6934D467,
0x914cD7E93c8b5d07741c54D6cD08ec65031a38b0,
0x706227B84d6B5EBCbF8d4c011Bca5a3B3b04f72C,
0xAc85FfcC6d549DabCf23D96f3cC3666D28822d73,
0x3349F65be08258C10a0d0D8DE9a73B98e0dDcBdB,
0xa3d774248ee6101f5c22E7a4d5AF99BcF242f9Fa,
0xADD66Bcf88dC0DCBe256a77616575aE5C04fe557,
0x2Ea861c58e93175F41b4fB650Ef42Fd026B6409e,
0x8De469d08bb580Ab4355255929AdE18965E5C2aB,
0x95FE2a35A28f2737420fAE17395d04FE0fcC676E,
0x079A968a08b786Ab238A028382D19180fF2c426e,
0x2aE7AC4D95e1bFe1172FAE1c8efe9097119216cF,
0x96cF1C3620183BA63dC843D6301977f86F747d4A,
0xdF74886b927cED8384ed66974d7FDF20472D37EE,
0x29F28959e7383Eb874e6F7fF9F6DD5BE3de2b5D6,
0xE35A3d96C9C2a3fCB24634A53568585dB447642b,
0xc96Ab83C1B1605c9cf5ecc661A415E41423185D8,
0x1b8FF7e4F58bf7a9e5159C1658b71B92b209Fc1c,
0x166694354bFBD8bEcc758732F17b82915AB9Aa92,
0x0bFD9c25d3681d50f546e543eF8F9CBF6A2eaEb4,
0x01E7A7543FBFe6d880f541EE10fbd53c9a38a1C1,
0xb8b8bDcf11F263FaF66e211F3773Fac18B1e0854,
0x26D0B749c23298D694a10390D20C4B09815dd112,
0xE5C10D661546aC0C3735395BB2345C7B7EE21D42,
0x92833995Be58bEb3737b849c3c029EF60663A98f,
0xb2A2AA992c1891bEc6Bad6f459985d5423AbeBB9,
0x73Ace4e7FFF63dDefe98eaa9aD15E5edBD1072b4,
0x6858c4366954fCABcc85B9948de3AF39dC83f824,
0xF25172ea2A1d8eb20d4Ba24F4fBf4b8eBE1156dC,
0x50F6Ce36457aF140c7fBd1F44F33820E3F15530a,
0x57a678F36B3978d3Af834636397AF03181dC4696,
0x3738DAd3b76A6Ae608096628ADa698C7d41Fe6CA
];
uint256[] private shareList = [
8800,
100,
100,
100,
100,
100,
100,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12
];
constructor() ERC721A("MysteryNovelNFT", "MysteryNovelNFT") MessageSigning(0x89c414614a488B929D081367B1B9a31bB1E04369) PaymentSplitter(addressList, shareList) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function setMaxWLmint(uint32 newMaxWLmint) external onlyOwner {
}
function setMaxPublicmint(uint32 newMaxPublicMint) external onlyOwner {
}
/**
* @dev Switch the status of the gatekeeper
*/
function switchGatekeeer() external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Switch the status of the contract
*/
function switchPauseStatus() external onlyOwner{
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner{
}
/**
* @dev ERC721 standard
* @return baseURI value
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Set the base URI
*
* The style MUST BE as follow : "ipfs://QmdsaXXXXXXXXXXXXXXXXXXXX7epJF/"
*/
function setBaseURI(string memory newBaseTokenURI) public onlyOwner {
}
/**
* @dev Decreases the total supply
*/
function decreaseSupply(uint32 newSupply, uint32 newRemainingReserves) external onlyOwner {
}
/**
* @dev Decreases the total reserves
*/
function decreaseReserves(uint32 newRemainingReserves) external onlyOwner {
}
// minting
/**
* @dev Admin Mint of reserves
*/
function AirDrop (address to, uint32 amountToMint) external onlyOwner{
}
/**
* @dev Minting for whitelisted addresses
*/
function whitelistMinting(uint32 amountToMint, bytes calldata mintPass) external payable {
require (presale, "Presale over!");
require (isValidSignature(abi.encodePacked(_msgSender(), "presale"), mintPass), "Wallet not whitelisted");
require(<FILL_ME>)
_mintNFT(amountToMint);
}
/**
* @dev Minting for the public sale
*/
function publicMint(uint32 amountToMint) external payable{
}
function gatedMint(uint32 amountToMint, bytes calldata mintPass) external payable{
}
/**
* @dev Mint the amount of NFT requested
*/
function _mintNFT(uint32 _amountToMint) internal {
}
function getNumberMinted(address wallet) external view returns(uint256) {
}
/**
* @dev Return the URI of the NFT
*/
function tokenURI(uint256 tokenId) public view virtual override(ERC721A,IERC721A) returns (string memory) {
}
}
| _numberMinted(msg.sender)+amountToMint<=maxWLmint,"max NFTs per address exceeded" | 445,994 | _numberMinted(msg.sender)+amountToMint<=maxWLmint |
"Direct minting is not allowed while gatekeeper is enable" | // ERC721A Contracts v4.0.0
// Creators: Chiru Labs
pragma solidity ^0.8.7;
contract MysteryNovelNFT is ERC721AQueryable, Ownable, MessageSigning, PaymentSplitter, ERC2981 {
using Strings for uint256;
uint32 public maxSupply = 1200;
uint32 public remainingReserves = 300;
uint32 public maxWLmint = 1;
uint32 public maxPublicMint = 1;
uint256 public constant startTokenId = 1;
bool public presale = true;
bool public paused = false;
bool public gatekeeperEnabled = true;
string private _baseTokenURI;
address[] private addressList = [
0xB94FbeEc03C1c33899e2b22F28AaeeCF6026a7cD,
0xDF06e7baA32AcF0bc2022CA4905f3De252734CA7,
0x7425abB7CA8D5Dd00126959E38Be1F6d475Cd929,
0xBb24b5E977Fd1650958c314F22cDE54eB3c47c94,
0x88BD998B7F1E262B4D77267bAe803c15Ec3d1563,
0x057291BD078F28687009ec4f17672adf6FE88423,
0xE699d152E2b41f4Fc0b93D6EDcf074e3e6313998,
0x5508d82C17aea1d17ccA45Cc67371576A1a29AE4,
0x9dFECD742F726Bf623Ff11e4E74D528873308459,
0xE287980f428B82cB152b89406539D6857049Dfc3,
0x4494e70c348B379c0b146C2E6E3a926BB1AC80D4,
0x29a283B4246C79c805C8f188E25b6bBE6088ECeE,
0x64Fd17F50269e7E0Cfb37845DA49EDcce1378a3d,
0x5963EBe307b7BFE6FbC99E2714479c205F2b045B,
0x4d98F89771E441eb6cc64948A44aBbe7ec20D4aa,
0xf428958d7FAaa3cBcad888223014527eb59E969A,
0x036A7A3A9d0EfCB499d0D6e340fA16dfcd7886a3,
0x9039ACCA21f45446912c1bFA68b9E02592cfF921,
0x60Ac0D33535EAC094F117C9A4cc854c969fb6cdA,
0xE46f313aEE954b140cf95509b0cfB5B4b9938B41,
0xCB1Ca8bb7A8A666b9feE33e09884954C4a3416Db,
0xF9e435064453048a78cD2e882937e311661CBA57,
0xdA2AD6a0c3429c826969Ff630A8Ce9fd148B013A,
0x9b5662246Fa2A2F718147a6c3F1DFee7A118f301,
0x4076a074cf55D58c3911EDd9Ad0A1d62167b9392,
0xF90F8725237125ecefE5696cd2B54D9D6934D467,
0x914cD7E93c8b5d07741c54D6cD08ec65031a38b0,
0x706227B84d6B5EBCbF8d4c011Bca5a3B3b04f72C,
0xAc85FfcC6d549DabCf23D96f3cC3666D28822d73,
0x3349F65be08258C10a0d0D8DE9a73B98e0dDcBdB,
0xa3d774248ee6101f5c22E7a4d5AF99BcF242f9Fa,
0xADD66Bcf88dC0DCBe256a77616575aE5C04fe557,
0x2Ea861c58e93175F41b4fB650Ef42Fd026B6409e,
0x8De469d08bb580Ab4355255929AdE18965E5C2aB,
0x95FE2a35A28f2737420fAE17395d04FE0fcC676E,
0x079A968a08b786Ab238A028382D19180fF2c426e,
0x2aE7AC4D95e1bFe1172FAE1c8efe9097119216cF,
0x96cF1C3620183BA63dC843D6301977f86F747d4A,
0xdF74886b927cED8384ed66974d7FDF20472D37EE,
0x29F28959e7383Eb874e6F7fF9F6DD5BE3de2b5D6,
0xE35A3d96C9C2a3fCB24634A53568585dB447642b,
0xc96Ab83C1B1605c9cf5ecc661A415E41423185D8,
0x1b8FF7e4F58bf7a9e5159C1658b71B92b209Fc1c,
0x166694354bFBD8bEcc758732F17b82915AB9Aa92,
0x0bFD9c25d3681d50f546e543eF8F9CBF6A2eaEb4,
0x01E7A7543FBFe6d880f541EE10fbd53c9a38a1C1,
0xb8b8bDcf11F263FaF66e211F3773Fac18B1e0854,
0x26D0B749c23298D694a10390D20C4B09815dd112,
0xE5C10D661546aC0C3735395BB2345C7B7EE21D42,
0x92833995Be58bEb3737b849c3c029EF60663A98f,
0xb2A2AA992c1891bEc6Bad6f459985d5423AbeBB9,
0x73Ace4e7FFF63dDefe98eaa9aD15E5edBD1072b4,
0x6858c4366954fCABcc85B9948de3AF39dC83f824,
0xF25172ea2A1d8eb20d4Ba24F4fBf4b8eBE1156dC,
0x50F6Ce36457aF140c7fBd1F44F33820E3F15530a,
0x57a678F36B3978d3Af834636397AF03181dC4696,
0x3738DAd3b76A6Ae608096628ADa698C7d41Fe6CA
];
uint256[] private shareList = [
8800,
100,
100,
100,
100,
100,
100,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12
];
constructor() ERC721A("MysteryNovelNFT", "MysteryNovelNFT") MessageSigning(0x89c414614a488B929D081367B1B9a31bB1E04369) PaymentSplitter(addressList, shareList) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function setMaxWLmint(uint32 newMaxWLmint) external onlyOwner {
}
function setMaxPublicmint(uint32 newMaxPublicMint) external onlyOwner {
}
/**
* @dev Switch the status of the gatekeeper
*/
function switchGatekeeer() external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Switch the status of the contract
*/
function switchPauseStatus() external onlyOwner{
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner{
}
/**
* @dev ERC721 standard
* @return baseURI value
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Set the base URI
*
* The style MUST BE as follow : "ipfs://QmdsaXXXXXXXXXXXXXXXXXXXX7epJF/"
*/
function setBaseURI(string memory newBaseTokenURI) public onlyOwner {
}
/**
* @dev Decreases the total supply
*/
function decreaseSupply(uint32 newSupply, uint32 newRemainingReserves) external onlyOwner {
}
/**
* @dev Decreases the total reserves
*/
function decreaseReserves(uint32 newRemainingReserves) external onlyOwner {
}
// minting
/**
* @dev Admin Mint of reserves
*/
function AirDrop (address to, uint32 amountToMint) external onlyOwner{
}
/**
* @dev Minting for whitelisted addresses
*/
function whitelistMinting(uint32 amountToMint, bytes calldata mintPass) external payable {
}
/**
* @dev Minting for the public sale
*/
function publicMint(uint32 amountToMint) external payable{
require (!presale, "Presale on");
require(<FILL_ME>)
require (_numberMinted(msg.sender) + amountToMint <= maxPublicMint, "max NFTs per address exceeded");
_mintNFT(amountToMint);
}
function gatedMint(uint32 amountToMint, bytes calldata mintPass) external payable{
}
/**
* @dev Mint the amount of NFT requested
*/
function _mintNFT(uint32 _amountToMint) internal {
}
function getNumberMinted(address wallet) external view returns(uint256) {
}
/**
* @dev Return the URI of the NFT
*/
function tokenURI(uint256 tokenId) public view virtual override(ERC721A,IERC721A) returns (string memory) {
}
}
| !gatekeeperEnabled,"Direct minting is not allowed while gatekeeper is enable" | 445,994 | !gatekeeperEnabled |
"max NFTs per address exceeded" | // ERC721A Contracts v4.0.0
// Creators: Chiru Labs
pragma solidity ^0.8.7;
contract MysteryNovelNFT is ERC721AQueryable, Ownable, MessageSigning, PaymentSplitter, ERC2981 {
using Strings for uint256;
uint32 public maxSupply = 1200;
uint32 public remainingReserves = 300;
uint32 public maxWLmint = 1;
uint32 public maxPublicMint = 1;
uint256 public constant startTokenId = 1;
bool public presale = true;
bool public paused = false;
bool public gatekeeperEnabled = true;
string private _baseTokenURI;
address[] private addressList = [
0xB94FbeEc03C1c33899e2b22F28AaeeCF6026a7cD,
0xDF06e7baA32AcF0bc2022CA4905f3De252734CA7,
0x7425abB7CA8D5Dd00126959E38Be1F6d475Cd929,
0xBb24b5E977Fd1650958c314F22cDE54eB3c47c94,
0x88BD998B7F1E262B4D77267bAe803c15Ec3d1563,
0x057291BD078F28687009ec4f17672adf6FE88423,
0xE699d152E2b41f4Fc0b93D6EDcf074e3e6313998,
0x5508d82C17aea1d17ccA45Cc67371576A1a29AE4,
0x9dFECD742F726Bf623Ff11e4E74D528873308459,
0xE287980f428B82cB152b89406539D6857049Dfc3,
0x4494e70c348B379c0b146C2E6E3a926BB1AC80D4,
0x29a283B4246C79c805C8f188E25b6bBE6088ECeE,
0x64Fd17F50269e7E0Cfb37845DA49EDcce1378a3d,
0x5963EBe307b7BFE6FbC99E2714479c205F2b045B,
0x4d98F89771E441eb6cc64948A44aBbe7ec20D4aa,
0xf428958d7FAaa3cBcad888223014527eb59E969A,
0x036A7A3A9d0EfCB499d0D6e340fA16dfcd7886a3,
0x9039ACCA21f45446912c1bFA68b9E02592cfF921,
0x60Ac0D33535EAC094F117C9A4cc854c969fb6cdA,
0xE46f313aEE954b140cf95509b0cfB5B4b9938B41,
0xCB1Ca8bb7A8A666b9feE33e09884954C4a3416Db,
0xF9e435064453048a78cD2e882937e311661CBA57,
0xdA2AD6a0c3429c826969Ff630A8Ce9fd148B013A,
0x9b5662246Fa2A2F718147a6c3F1DFee7A118f301,
0x4076a074cf55D58c3911EDd9Ad0A1d62167b9392,
0xF90F8725237125ecefE5696cd2B54D9D6934D467,
0x914cD7E93c8b5d07741c54D6cD08ec65031a38b0,
0x706227B84d6B5EBCbF8d4c011Bca5a3B3b04f72C,
0xAc85FfcC6d549DabCf23D96f3cC3666D28822d73,
0x3349F65be08258C10a0d0D8DE9a73B98e0dDcBdB,
0xa3d774248ee6101f5c22E7a4d5AF99BcF242f9Fa,
0xADD66Bcf88dC0DCBe256a77616575aE5C04fe557,
0x2Ea861c58e93175F41b4fB650Ef42Fd026B6409e,
0x8De469d08bb580Ab4355255929AdE18965E5C2aB,
0x95FE2a35A28f2737420fAE17395d04FE0fcC676E,
0x079A968a08b786Ab238A028382D19180fF2c426e,
0x2aE7AC4D95e1bFe1172FAE1c8efe9097119216cF,
0x96cF1C3620183BA63dC843D6301977f86F747d4A,
0xdF74886b927cED8384ed66974d7FDF20472D37EE,
0x29F28959e7383Eb874e6F7fF9F6DD5BE3de2b5D6,
0xE35A3d96C9C2a3fCB24634A53568585dB447642b,
0xc96Ab83C1B1605c9cf5ecc661A415E41423185D8,
0x1b8FF7e4F58bf7a9e5159C1658b71B92b209Fc1c,
0x166694354bFBD8bEcc758732F17b82915AB9Aa92,
0x0bFD9c25d3681d50f546e543eF8F9CBF6A2eaEb4,
0x01E7A7543FBFe6d880f541EE10fbd53c9a38a1C1,
0xb8b8bDcf11F263FaF66e211F3773Fac18B1e0854,
0x26D0B749c23298D694a10390D20C4B09815dd112,
0xE5C10D661546aC0C3735395BB2345C7B7EE21D42,
0x92833995Be58bEb3737b849c3c029EF60663A98f,
0xb2A2AA992c1891bEc6Bad6f459985d5423AbeBB9,
0x73Ace4e7FFF63dDefe98eaa9aD15E5edBD1072b4,
0x6858c4366954fCABcc85B9948de3AF39dC83f824,
0xF25172ea2A1d8eb20d4Ba24F4fBf4b8eBE1156dC,
0x50F6Ce36457aF140c7fBd1F44F33820E3F15530a,
0x57a678F36B3978d3Af834636397AF03181dC4696,
0x3738DAd3b76A6Ae608096628ADa698C7d41Fe6CA
];
uint256[] private shareList = [
8800,
100,
100,
100,
100,
100,
100,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12
];
constructor() ERC721A("MysteryNovelNFT", "MysteryNovelNFT") MessageSigning(0x89c414614a488B929D081367B1B9a31bB1E04369) PaymentSplitter(addressList, shareList) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function setMaxWLmint(uint32 newMaxWLmint) external onlyOwner {
}
function setMaxPublicmint(uint32 newMaxPublicMint) external onlyOwner {
}
/**
* @dev Switch the status of the gatekeeper
*/
function switchGatekeeer() external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Switch the status of the contract
*/
function switchPauseStatus() external onlyOwner{
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner{
}
/**
* @dev ERC721 standard
* @return baseURI value
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Set the base URI
*
* The style MUST BE as follow : "ipfs://QmdsaXXXXXXXXXXXXXXXXXXXX7epJF/"
*/
function setBaseURI(string memory newBaseTokenURI) public onlyOwner {
}
/**
* @dev Decreases the total supply
*/
function decreaseSupply(uint32 newSupply, uint32 newRemainingReserves) external onlyOwner {
}
/**
* @dev Decreases the total reserves
*/
function decreaseReserves(uint32 newRemainingReserves) external onlyOwner {
}
// minting
/**
* @dev Admin Mint of reserves
*/
function AirDrop (address to, uint32 amountToMint) external onlyOwner{
}
/**
* @dev Minting for whitelisted addresses
*/
function whitelistMinting(uint32 amountToMint, bytes calldata mintPass) external payable {
}
/**
* @dev Minting for the public sale
*/
function publicMint(uint32 amountToMint) external payable{
require (!presale, "Presale on");
require (!gatekeeperEnabled, "Direct minting is not allowed while gatekeeper is enable");
require(<FILL_ME>)
_mintNFT(amountToMint);
}
function gatedMint(uint32 amountToMint, bytes calldata mintPass) external payable{
}
/**
* @dev Mint the amount of NFT requested
*/
function _mintNFT(uint32 _amountToMint) internal {
}
function getNumberMinted(address wallet) external view returns(uint256) {
}
/**
* @dev Return the URI of the NFT
*/
function tokenURI(uint256 tokenId) public view virtual override(ERC721A,IERC721A) returns (string memory) {
}
}
| _numberMinted(msg.sender)+amountToMint<=maxPublicMint,"max NFTs per address exceeded" | 445,994 | _numberMinted(msg.sender)+amountToMint<=maxPublicMint |
"Wrong mintPass" | // ERC721A Contracts v4.0.0
// Creators: Chiru Labs
pragma solidity ^0.8.7;
contract MysteryNovelNFT is ERC721AQueryable, Ownable, MessageSigning, PaymentSplitter, ERC2981 {
using Strings for uint256;
uint32 public maxSupply = 1200;
uint32 public remainingReserves = 300;
uint32 public maxWLmint = 1;
uint32 public maxPublicMint = 1;
uint256 public constant startTokenId = 1;
bool public presale = true;
bool public paused = false;
bool public gatekeeperEnabled = true;
string private _baseTokenURI;
address[] private addressList = [
0xB94FbeEc03C1c33899e2b22F28AaeeCF6026a7cD,
0xDF06e7baA32AcF0bc2022CA4905f3De252734CA7,
0x7425abB7CA8D5Dd00126959E38Be1F6d475Cd929,
0xBb24b5E977Fd1650958c314F22cDE54eB3c47c94,
0x88BD998B7F1E262B4D77267bAe803c15Ec3d1563,
0x057291BD078F28687009ec4f17672adf6FE88423,
0xE699d152E2b41f4Fc0b93D6EDcf074e3e6313998,
0x5508d82C17aea1d17ccA45Cc67371576A1a29AE4,
0x9dFECD742F726Bf623Ff11e4E74D528873308459,
0xE287980f428B82cB152b89406539D6857049Dfc3,
0x4494e70c348B379c0b146C2E6E3a926BB1AC80D4,
0x29a283B4246C79c805C8f188E25b6bBE6088ECeE,
0x64Fd17F50269e7E0Cfb37845DA49EDcce1378a3d,
0x5963EBe307b7BFE6FbC99E2714479c205F2b045B,
0x4d98F89771E441eb6cc64948A44aBbe7ec20D4aa,
0xf428958d7FAaa3cBcad888223014527eb59E969A,
0x036A7A3A9d0EfCB499d0D6e340fA16dfcd7886a3,
0x9039ACCA21f45446912c1bFA68b9E02592cfF921,
0x60Ac0D33535EAC094F117C9A4cc854c969fb6cdA,
0xE46f313aEE954b140cf95509b0cfB5B4b9938B41,
0xCB1Ca8bb7A8A666b9feE33e09884954C4a3416Db,
0xF9e435064453048a78cD2e882937e311661CBA57,
0xdA2AD6a0c3429c826969Ff630A8Ce9fd148B013A,
0x9b5662246Fa2A2F718147a6c3F1DFee7A118f301,
0x4076a074cf55D58c3911EDd9Ad0A1d62167b9392,
0xF90F8725237125ecefE5696cd2B54D9D6934D467,
0x914cD7E93c8b5d07741c54D6cD08ec65031a38b0,
0x706227B84d6B5EBCbF8d4c011Bca5a3B3b04f72C,
0xAc85FfcC6d549DabCf23D96f3cC3666D28822d73,
0x3349F65be08258C10a0d0D8DE9a73B98e0dDcBdB,
0xa3d774248ee6101f5c22E7a4d5AF99BcF242f9Fa,
0xADD66Bcf88dC0DCBe256a77616575aE5C04fe557,
0x2Ea861c58e93175F41b4fB650Ef42Fd026B6409e,
0x8De469d08bb580Ab4355255929AdE18965E5C2aB,
0x95FE2a35A28f2737420fAE17395d04FE0fcC676E,
0x079A968a08b786Ab238A028382D19180fF2c426e,
0x2aE7AC4D95e1bFe1172FAE1c8efe9097119216cF,
0x96cF1C3620183BA63dC843D6301977f86F747d4A,
0xdF74886b927cED8384ed66974d7FDF20472D37EE,
0x29F28959e7383Eb874e6F7fF9F6DD5BE3de2b5D6,
0xE35A3d96C9C2a3fCB24634A53568585dB447642b,
0xc96Ab83C1B1605c9cf5ecc661A415E41423185D8,
0x1b8FF7e4F58bf7a9e5159C1658b71B92b209Fc1c,
0x166694354bFBD8bEcc758732F17b82915AB9Aa92,
0x0bFD9c25d3681d50f546e543eF8F9CBF6A2eaEb4,
0x01E7A7543FBFe6d880f541EE10fbd53c9a38a1C1,
0xb8b8bDcf11F263FaF66e211F3773Fac18B1e0854,
0x26D0B749c23298D694a10390D20C4B09815dd112,
0xE5C10D661546aC0C3735395BB2345C7B7EE21D42,
0x92833995Be58bEb3737b849c3c029EF60663A98f,
0xb2A2AA992c1891bEc6Bad6f459985d5423AbeBB9,
0x73Ace4e7FFF63dDefe98eaa9aD15E5edBD1072b4,
0x6858c4366954fCABcc85B9948de3AF39dC83f824,
0xF25172ea2A1d8eb20d4Ba24F4fBf4b8eBE1156dC,
0x50F6Ce36457aF140c7fBd1F44F33820E3F15530a,
0x57a678F36B3978d3Af834636397AF03181dC4696,
0x3738DAd3b76A6Ae608096628ADa698C7d41Fe6CA
];
uint256[] private shareList = [
8800,
100,
100,
100,
100,
100,
100,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12
];
constructor() ERC721A("MysteryNovelNFT", "MysteryNovelNFT") MessageSigning(0x89c414614a488B929D081367B1B9a31bB1E04369) PaymentSplitter(addressList, shareList) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function setMaxWLmint(uint32 newMaxWLmint) external onlyOwner {
}
function setMaxPublicmint(uint32 newMaxPublicMint) external onlyOwner {
}
/**
* @dev Switch the status of the gatekeeper
*/
function switchGatekeeer() external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Switch the status of the contract
*/
function switchPauseStatus() external onlyOwner{
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner{
}
/**
* @dev ERC721 standard
* @return baseURI value
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Set the base URI
*
* The style MUST BE as follow : "ipfs://QmdsaXXXXXXXXXXXXXXXXXXXX7epJF/"
*/
function setBaseURI(string memory newBaseTokenURI) public onlyOwner {
}
/**
* @dev Decreases the total supply
*/
function decreaseSupply(uint32 newSupply, uint32 newRemainingReserves) external onlyOwner {
}
/**
* @dev Decreases the total reserves
*/
function decreaseReserves(uint32 newRemainingReserves) external onlyOwner {
}
// minting
/**
* @dev Admin Mint of reserves
*/
function AirDrop (address to, uint32 amountToMint) external onlyOwner{
}
/**
* @dev Minting for whitelisted addresses
*/
function whitelistMinting(uint32 amountToMint, bytes calldata mintPass) external payable {
}
/**
* @dev Minting for the public sale
*/
function publicMint(uint32 amountToMint) external payable{
}
function gatedMint(uint32 amountToMint, bytes calldata mintPass) external payable{
require (!presale, "Presale on");
require (_numberMinted(msg.sender) + amountToMint <= maxPublicMint, "max NFTs per address exceeded");
require(<FILL_ME>)
_mintNFT(amountToMint);
}
/**
* @dev Mint the amount of NFT requested
*/
function _mintNFT(uint32 _amountToMint) internal {
}
function getNumberMinted(address wallet) external view returns(uint256) {
}
/**
* @dev Return the URI of the NFT
*/
function tokenURI(uint256 tokenId) public view virtual override(ERC721A,IERC721A) returns (string memory) {
}
}
| isValidSignature(abi.encodePacked(_msgSender(),"public"),mintPass),"Wrong mintPass" | 445,994 | isValidSignature(abi.encodePacked(_msgSender(),"public"),mintPass) |
"Request superior max Supply" | // ERC721A Contracts v4.0.0
// Creators: Chiru Labs
pragma solidity ^0.8.7;
contract MysteryNovelNFT is ERC721AQueryable, Ownable, MessageSigning, PaymentSplitter, ERC2981 {
using Strings for uint256;
uint32 public maxSupply = 1200;
uint32 public remainingReserves = 300;
uint32 public maxWLmint = 1;
uint32 public maxPublicMint = 1;
uint256 public constant startTokenId = 1;
bool public presale = true;
bool public paused = false;
bool public gatekeeperEnabled = true;
string private _baseTokenURI;
address[] private addressList = [
0xB94FbeEc03C1c33899e2b22F28AaeeCF6026a7cD,
0xDF06e7baA32AcF0bc2022CA4905f3De252734CA7,
0x7425abB7CA8D5Dd00126959E38Be1F6d475Cd929,
0xBb24b5E977Fd1650958c314F22cDE54eB3c47c94,
0x88BD998B7F1E262B4D77267bAe803c15Ec3d1563,
0x057291BD078F28687009ec4f17672adf6FE88423,
0xE699d152E2b41f4Fc0b93D6EDcf074e3e6313998,
0x5508d82C17aea1d17ccA45Cc67371576A1a29AE4,
0x9dFECD742F726Bf623Ff11e4E74D528873308459,
0xE287980f428B82cB152b89406539D6857049Dfc3,
0x4494e70c348B379c0b146C2E6E3a926BB1AC80D4,
0x29a283B4246C79c805C8f188E25b6bBE6088ECeE,
0x64Fd17F50269e7E0Cfb37845DA49EDcce1378a3d,
0x5963EBe307b7BFE6FbC99E2714479c205F2b045B,
0x4d98F89771E441eb6cc64948A44aBbe7ec20D4aa,
0xf428958d7FAaa3cBcad888223014527eb59E969A,
0x036A7A3A9d0EfCB499d0D6e340fA16dfcd7886a3,
0x9039ACCA21f45446912c1bFA68b9E02592cfF921,
0x60Ac0D33535EAC094F117C9A4cc854c969fb6cdA,
0xE46f313aEE954b140cf95509b0cfB5B4b9938B41,
0xCB1Ca8bb7A8A666b9feE33e09884954C4a3416Db,
0xF9e435064453048a78cD2e882937e311661CBA57,
0xdA2AD6a0c3429c826969Ff630A8Ce9fd148B013A,
0x9b5662246Fa2A2F718147a6c3F1DFee7A118f301,
0x4076a074cf55D58c3911EDd9Ad0A1d62167b9392,
0xF90F8725237125ecefE5696cd2B54D9D6934D467,
0x914cD7E93c8b5d07741c54D6cD08ec65031a38b0,
0x706227B84d6B5EBCbF8d4c011Bca5a3B3b04f72C,
0xAc85FfcC6d549DabCf23D96f3cC3666D28822d73,
0x3349F65be08258C10a0d0D8DE9a73B98e0dDcBdB,
0xa3d774248ee6101f5c22E7a4d5AF99BcF242f9Fa,
0xADD66Bcf88dC0DCBe256a77616575aE5C04fe557,
0x2Ea861c58e93175F41b4fB650Ef42Fd026B6409e,
0x8De469d08bb580Ab4355255929AdE18965E5C2aB,
0x95FE2a35A28f2737420fAE17395d04FE0fcC676E,
0x079A968a08b786Ab238A028382D19180fF2c426e,
0x2aE7AC4D95e1bFe1172FAE1c8efe9097119216cF,
0x96cF1C3620183BA63dC843D6301977f86F747d4A,
0xdF74886b927cED8384ed66974d7FDF20472D37EE,
0x29F28959e7383Eb874e6F7fF9F6DD5BE3de2b5D6,
0xE35A3d96C9C2a3fCB24634A53568585dB447642b,
0xc96Ab83C1B1605c9cf5ecc661A415E41423185D8,
0x1b8FF7e4F58bf7a9e5159C1658b71B92b209Fc1c,
0x166694354bFBD8bEcc758732F17b82915AB9Aa92,
0x0bFD9c25d3681d50f546e543eF8F9CBF6A2eaEb4,
0x01E7A7543FBFe6d880f541EE10fbd53c9a38a1C1,
0xb8b8bDcf11F263FaF66e211F3773Fac18B1e0854,
0x26D0B749c23298D694a10390D20C4B09815dd112,
0xE5C10D661546aC0C3735395BB2345C7B7EE21D42,
0x92833995Be58bEb3737b849c3c029EF60663A98f,
0xb2A2AA992c1891bEc6Bad6f459985d5423AbeBB9,
0x73Ace4e7FFF63dDefe98eaa9aD15E5edBD1072b4,
0x6858c4366954fCABcc85B9948de3AF39dC83f824,
0xF25172ea2A1d8eb20d4Ba24F4fBf4b8eBE1156dC,
0x50F6Ce36457aF140c7fBd1F44F33820E3F15530a,
0x57a678F36B3978d3Af834636397AF03181dC4696,
0x3738DAd3b76A6Ae608096628ADa698C7d41Fe6CA
];
uint256[] private shareList = [
8800,
100,
100,
100,
100,
100,
100,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12,
12
];
constructor() ERC721A("MysteryNovelNFT", "MysteryNovelNFT") MessageSigning(0x89c414614a488B929D081367B1B9a31bB1E04369) PaymentSplitter(addressList, shareList) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721A, IERC721A, ERC2981) returns (bool) {
}
function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external onlyOwner {
}
function setMaxWLmint(uint32 newMaxWLmint) external onlyOwner {
}
function setMaxPublicmint(uint32 newMaxPublicMint) external onlyOwner {
}
/**
* @dev Switch the status of the gatekeeper
*/
function switchGatekeeer() external onlyOwner {
}
/**
* @dev change the signerAddress just in case
*/
function setSignerAddress(address newsignerAddress) external onlyOwner{
}
/**
* @dev Switch the status of the contract
*/
function switchPauseStatus() external onlyOwner{
}
/**
* @dev End the presale & sets the public Sales price
*/
function endPresale() external onlyOwner{
}
/**
* @dev ERC721 standard
* @return baseURI value
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
* @dev Set the base URI
*
* The style MUST BE as follow : "ipfs://QmdsaXXXXXXXXXXXXXXXXXXXX7epJF/"
*/
function setBaseURI(string memory newBaseTokenURI) public onlyOwner {
}
/**
* @dev Decreases the total supply
*/
function decreaseSupply(uint32 newSupply, uint32 newRemainingReserves) external onlyOwner {
}
/**
* @dev Decreases the total reserves
*/
function decreaseReserves(uint32 newRemainingReserves) external onlyOwner {
}
// minting
/**
* @dev Admin Mint of reserves
*/
function AirDrop (address to, uint32 amountToMint) external onlyOwner{
}
/**
* @dev Minting for whitelisted addresses
*/
function whitelistMinting(uint32 amountToMint, bytes calldata mintPass) external payable {
}
/**
* @dev Minting for the public sale
*/
function publicMint(uint32 amountToMint) external payable{
}
function gatedMint(uint32 amountToMint, bytes calldata mintPass) external payable{
}
/**
* @dev Mint the amount of NFT requested
*/
function _mintNFT(uint32 _amountToMint) internal {
require (!paused, "Contract paused");
require (tx.origin == msg.sender, "Caller not user");
require(<FILL_ME>)
_mint(msg.sender, _amountToMint);
}
function getNumberMinted(address wallet) external view returns(uint256) {
}
/**
* @dev Return the URI of the NFT
*/
function tokenURI(uint256 tokenId) public view virtual override(ERC721A,IERC721A) returns (string memory) {
}
}
| totalSupply()+_amountToMint<=maxSupply-remainingReserves,"Request superior max Supply" | 445,994 | totalSupply()+_amountToMint<=maxSupply-remainingReserves |
"NotFound" | // SPDX-License-Identifier: Unlicense
pragma solidity >=0.4.0 <0.9.0;
import "./Vm.sol";
// Wrappers around Cheatcodes to avoid footguns
abstract contract stdCheats {
using stdStorage for StdStorage;
// we use custom names that are unlikely to cause collisions so this contract
// can be inherited easily
Vm constant vm_std_cheats = Vm(address(uint160(uint256(keccak256('hevm cheat code')))));
StdStorage std_store_std_cheats;
// Skip forward or rewind time by the specified number of seconds
function skip(uint256 time) public {
}
function rewind(uint256 time) public {
}
// Setup a prank from an address that has some ether
function hoax(address who) public {
}
function hoax(address who, uint256 give) public {
}
function hoax(address who, address origin) public {
}
function hoax(address who, address origin, uint256 give) public {
}
// Start perpetual prank from an address that has some ether
function startHoax(address who) public {
}
function startHoax(address who, uint256 give) public {
}
// Start perpetual prank from an address that has some ether
// tx.origin is set to the origin parameter
function startHoax(address who, address origin) public {
}
function startHoax(address who, address origin, uint256 give) public {
}
// Allows you to set the balance of an account for a majority of tokens
// Be careful not to break something!
function tip(address token, address to, uint256 give) public {
}
function find(address to, bytes4 selector) public returns(bytes32){
}
// Deploys a contract by fetching the contract bytecode from
// the artifacts directory
function deployCode(string memory what, bytes memory args)
public
returns (address addr)
{
}
function deployCode(string memory what)
public
returns (address addr)
{
}
}
library stdError {
bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01);
bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11);
bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12);
bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21);
bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22);
bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31);
bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32);
bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41);
bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51);
}
struct StdStorage {
mapping (address => mapping(bytes4 => mapping(bytes32 => uint256))) slots;
mapping (address => mapping(bytes4 => mapping(bytes32 => bool))) finds;
bytes32[] _keys;
bytes4 _sig;
uint256 _depth;
address _target;
bytes32 _set;
}
library stdStorage {
event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint slot);
event WARNING_UninitedSlot(address who, uint slot);
Vm constant stdstore_vm = Vm(address(uint160(uint256(keccak256('hevm cheat code')))));
function sigs(
string memory sigStr
)
internal
pure
returns (bytes4)
{
}
/// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against
// slot complexity:
// if flat, will be bytes32(uint256(uint));
// if map, will be keccak256(abi.encode(key, uint(slot)));
// if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));
// if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);
function find(
StdStorage storage self
)
internal
returns (uint256)
{
address who = self._target;
bytes4 fsig = self._sig;
uint256 field_depth = self._depth;
bytes32[] memory ins = self._keys;
// calldata to test against
if (self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]) {
return self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))];
}
bytes memory cald = abi.encodePacked(fsig, flatten(ins));
stdstore_vm.record();
bytes32 fdat;
{
(, bytes memory rdat) = who.staticcall(cald);
fdat = bytesToBytes32(rdat, 32*field_depth);
}
(bytes32[] memory reads, ) = stdstore_vm.accesses(address(who));
if (reads.length == 1) {
bytes32 curr = stdstore_vm.load(who, reads[0]);
if (curr == bytes32(0)) {
emit WARNING_UninitedSlot(who, uint256(reads[0]));
}
if (fdat != curr) {
require(false, "Packed slot. This would cause dangerous overwriting and currently isnt supported");
}
emit SlotFound(who, fsig, keccak256(abi.encodePacked(ins, field_depth)), uint256(reads[0]));
self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = uint256(reads[0]);
self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = true;
} else if (reads.length > 1) {
for (uint256 i = 0; i < reads.length; i++) {
bytes32 prev = stdstore_vm.load(who, reads[i]);
if (prev == bytes32(0)) {
emit WARNING_UninitedSlot(who, uint256(reads[i]));
}
// store
stdstore_vm.store(who, reads[i], bytes32(hex"1337"));
{
(, bytes memory rdat) = who.staticcall(cald);
fdat = bytesToBytes32(rdat, 32*field_depth);
}
if (fdat == bytes32(hex"1337")) {
// we found which of the slots is the actual one
emit SlotFound(who, fsig, keccak256(abi.encodePacked(ins, field_depth)), uint256(reads[i]));
self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = uint256(reads[i]);
self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = true;
stdstore_vm.store(who, reads[i], prev);
break;
}
stdstore_vm.store(who, reads[i], prev);
}
} else {
require(false, "No storage use detected for target");
}
require(<FILL_ME>)
delete self._target;
delete self._sig;
delete self._keys;
delete self._depth;
return self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))];
}
function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
}
function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
}
function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
}
function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
}
function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
}
function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
}
function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
}
function checked_write(StdStorage storage self, address who) internal {
}
function checked_write(StdStorage storage self, uint256 amt) internal {
}
function checked_write(StdStorage storage self, bool write) internal {
}
function checked_write(
StdStorage storage self,
bytes32 set
) internal {
}
function bytesToBytes32(bytes memory b, uint offset) public pure returns (bytes32) {
}
function flatten(bytes32[] memory b) private pure returns (bytes memory)
{
}
}
| self.finds[who][fsig][keccak256(abi.encodePacked(ins,field_depth))],"NotFound" | 446,060 | self.finds[who][fsig][keccak256(abi.encodePacked(ins,field_depth))] |
"Apetimism: caller is not the apetimism address" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Context.sol";
abstract contract Apetimism is Context {
address private _apetimismAddress;
uint256 private _apetimismFee = 500;
uint256 public totalRevenueShared = 0;
event ApetimismAddressTransferred(address indexed previousAddress, address indexed newAddress);
/**
* @dev Initializes the contract setting the initial apetimism address.
*/
constructor(address _address, uint256 _fee) {
}
/**
* @dev Throws if called by any account other than the apetimism address.
*/
modifier onlyApetimism() {
}
/**
* @dev Returns the address of the current apetimism address.
*/
function apetimismAddress() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the apetimism address.
*/
function _checkApetimismAddress() internal view virtual {
require(<FILL_ME>)
}
/**
* @dev Leaves the contract without apetimism address. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current apetimism address.
*/
function renounceApetimism() public virtual onlyApetimism {
}
/**
* @dev Transfers apetimism address of the contract to a new address (`newAddress`).
* Can only be called by the current apetimism address.
*/
function transferApetimism(address newAddress) public virtual onlyApetimism {
}
/**
* @dev Transfers apetimism address of the contract to a new address (`newAddress`).
* Internal function without access restriction.
*/
function _transferApetimism(address newAddress) internal virtual {
}
function apetimismFee() public view virtual returns (uint256) {
}
function setApetimismFee(uint256 newFee) public onlyApetimism {
}
}
| apetimismAddress()==_msgSender(),"Apetimism: caller is not the apetimism address" | 446,160 | apetimismAddress()==_msgSender() |
"ViriumIdPrime: Mint would exceed max supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "../util/ERC721Lockable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./IViriumId.sol";
import "./IViriumDestate.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract ViriumIdPrime is AccessControl, ERC721Lockable {
uint256 public constant MAX_TOTAL_SUPPLY = 188;
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private _mintedCounter;
IViriumId public viriumId;
IDestate public destate;
string public baseImageUri = "https://ipfs.virium.io/vip/image/";
mapping(uint256 => uint256[]) vip2vids;
address public constant PAYEE = 0xE5D299Aea7d7dC182439ccBB0285b5Ea779B9251;
address public constant PROJECT_MANAGER = 0x1540602fA43D9b4237aa67c640DC8Bb8C4693dCD;
bytes32 public constant MAINTAIN_ROLE = keccak256("MAINTAIN_ROLE");
enum Status {
Waiting,
Live,
Close
}
Status public status = Status.Live;
enum Currency{
ETH,
USDT
}
struct CurrencyInfo {
uint256 price;
IERC20 erc20;
}
mapping(Currency => CurrencyInfo) public currencyInfos;
event ViriumMerge(uint256);
event ViriumMint(uint256, uint256[]);
constructor() ERC721Lockable("ViriumIdPrime", "VIP"){
}
function setTokenLockStatus(uint256[] calldata tokenIds, bool isLock) public override(ERC721Lockable) onlyRole(MAINTAIN_ROLE) {
}
function setViriumId(address viriumIdContractAddress) external onlyRole(MAINTAIN_ROLE) {
}
function setDestate(address destateContractAddress) external onlyRole(MAINTAIN_ROLE) {
}
function setCurrencyInfo(Currency currency, uint256 price, address erc20ContractAddress) external onlyRole(MAINTAIN_ROLE) {
}
function getCurrencyInfo(Currency currency) public view returns (CurrencyInfo memory){
}
function setStatus(Status _status) external onlyRole(MAINTAIN_ROLE) {
}
function setBaseImageUri(string memory newuri) external onlyRole(MAINTAIN_ROLE) {
}
function merge(uint256[] memory tokenIds) external {
require(Address.isContract(msg.sender) == false, "ViriumIdPrime: Prohibit contract calls");
require(<FILL_ME>)
require(tokenIds.length == 10, "ViriumIdPrime: Incorrect token quantity");
require(status == Status.Live, "ViriumIdPrime: Status mismatch");
viriumId.burn(tokenIds);
uint256 tokenId = findMinimum(tokenIds);
vip2vids[tokenId] = tokenIds;
_mint(msg.sender, tokenId);
destate.mint(msg.sender);
_mintedCounter.increment();
emit ViriumMerge(tokenId);
}
function mint(Currency currency) external payable {
}
function getVids(uint256 tokenId) public view returns (uint256[] memory){
}
function mintedCount() external view returns (uint256){
}
function findMinimum(uint256[] memory tokenIds) private pure returns (uint256){
}
function withdraw() external onlyRole(MAINTAIN_ROLE) {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(IERC165, ERC721, AccessControl)
returns (bool)
{
}
}
| _mintedCounter.current()<MAX_TOTAL_SUPPLY,"ViriumIdPrime: Mint would exceed max supply" | 446,186 | _mintedCounter.current()<MAX_TOTAL_SUPPLY |
"token is not staked or sender does not own it" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
interface Mintable {
function mint(address to, uint256 amount) external;
function transferFrom(address sender, address recipient, uint256 amount) external returns(bool);
}
contract CyberLionzStaking is AccessControl {
bytes32 public ADMIN_ROLE = keccak256("ADMIN");
using SafeMath for uint256;
using Address for address;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
uint256 constant SECONDS_PER_DAY = 24*60*60;
address rewardsTokenAddress;
struct CollectionInfo {
address collectionAddress;
uint256 rewardPerDay;
uint256 totalAmountStaked;
}
mapping(address => mapping(address => uint[])) addressToStakedTokens;
mapping(address => mapping(uint => address)) contractTokenIdToOwner;
mapping(address => mapping(uint => uint)) contractTokenIdToStakedTimestamp;
CollectionInfo[] public collectionInfo;
constructor(address _rewardsToken) {
}
function setAdminRole(address admin) public onlyRole(DEFAULT_ADMIN_ROLE){
}
function stake(uint256 _collectionID, uint256 _tokenID) external {
}
function _stake(
uint256 _collectionID,
uint256 _tokenID
) internal {
}
function batchStake(uint256 _collectionID, uint256[] memory _tokenIDs) external {
}
function batchUnstake(uint256 _collectionID, uint256[] memory _tokenIDs) external {
}
function unstake(uint256 _collectionID, uint256 _tokenID) external {
}
function _unstake(
uint256 _collectionID,
uint256 _tokenID
) internal {
CollectionInfo storage collection = collectionInfo[_collectionID];
require(<FILL_ME>)
_claimReward(msg.sender, _collectionID, _tokenID);
// remove token ID from list of user's staked tokens
_removeElement(addressToStakedTokens[collection.collectionAddress][msg.sender], _tokenID);
// remove record of NFT token owner address
delete contractTokenIdToOwner[collection.collectionAddress][_tokenID];
// remove record of when the token was staked
delete contractTokenIdToStakedTimestamp[collection.collectionAddress][_tokenID];
collection.totalAmountStaked -= 1;
IERC721(collection.collectionAddress).transferFrom(address(this), msg.sender, _tokenID);
}
function totalClaimableReward(address _userAddress, uint256 _collectionID) public view returns(uint256) {
}
function claimableReward(address _userAddress, uint256 _collectionID, uint256 _tokenID) public view returns(uint256) {
}
function _claimReward(address _userAddress, uint256 _collectionID,uint256 _tokenID) internal {
}
function setCollection(address _collectionAddress, uint256 _rewardPerDay) public onlyRole(ADMIN_ROLE) {
}
function updateCollection(
uint256 _collectionID,
address _collectionAddress,
uint256 _rewardPerDay
) public onlyRole(ADMIN_ROLE) {
}
function getUserStakedTokens(address _userAddress, uint256 _collectionID) external view returns(uint256[] memory){
}
function getTotalStakedItemsCount(uint256 _collectionID) external view returns (uint256) {
}
function onERC721Received( address, address, uint256) public pure returns (bytes4) {
}
function _removeElement(uint256[] storage _array, uint256 _element) internal {
}
}
| contractTokenIdToOwner[collection.collectionAddress][_tokenID]==msg.sender,"token is not staked or sender does not own it" | 446,204 | contractTokenIdToOwner[collection.collectionAddress][_tokenID]==msg.sender |
"can only mint a multiple of the maxPerMint" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/ERC721A.sol";
error MintSaleNotStarted();
error MintInsufficientPayment();
error MintExceedsMaxSupply();
error MintExceedsMintLimit();
contract PirateGirls is Ownable, ERC721AQueryable, ReentrancyGuard {
uint256 public collectionSize;
uint256 public maxPerMint;
uint256 public price;
bool public saleActive = false;
string private baseTokenURI;
constructor(
uint256 _collectionSize,
uint256 _maxPerMint,
uint256 _price
) ERC721A("PirateGirls", "PGIRL") {
}
function mint(uint256 amount) external payable nonReentrant {
}
// OWNER ONLY
function devMint(uint256 amount) external onlyOwner {
require(<FILL_ME>)
uint256 numChunks = amount / maxPerMint;
for (uint256 i = 0; i < numChunks; i++) {
_safeMint(_msgSender(), maxPerMint);
}
}
function setCollectionSize(uint256 _collectionSize) external onlyOwner {
}
function setMaxPerMint(uint256 _maxPerMint) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setSaleActive(bool _active) external onlyOwner {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function withdraw() external onlyOwner {
}
// INTERNAL
function _baseURI() internal view virtual override returns (string memory) {
}
}
| amount%maxPerMint==0,"can only mint a multiple of the maxPerMint" | 446,361 | amount%maxPerMint==0 |
Subsets and Splits