comment
stringlengths 1
211
โ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Already initialized" | // contracts/TokenImplementation.sol
// License-Identifier: Apache 2
pragma solidity ^0.8.0;
// Based on the OpenZepplin ERC20 implementation, licensed under MIT
contract TokenImplementation is IBurnable, IMintable, TokenState, Context {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function initialize(
string memory name_,
string memory symbol_,
uint8 decimals_,
uint64 sequence_,
address owner_,
uint16 chainId_,
bytes32 nativeContract_
) public initializer {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function owner() public view returns (address) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function chainId() public view returns (uint16) {
}
function nativeContract() public view returns (bytes32) {
}
function balanceOf(address account_) public view returns (uint256) {
}
function transfer(address recipient_, uint256 amount_) public returns (bool) {
}
function allowance(address owner_, address spender_) public view returns (uint256) {
}
function approve(address spender_, uint256 amount_) public returns (bool) {
}
function transferFrom(
address sender_,
address recipient_,
uint256 amount_
) public returns (bool) {
}
function increaseAllowance(address spender_, uint256 addedValue_) public returns (bool) {
}
function decreaseAllowance(address spender_, uint256 subtractedValue_) public returns (bool) {
}
function _transfer(
address sender_,
address recipient_,
uint256 amount_
) internal {
}
function mint(address account_, uint256 amount_) public override onlyOwner {
}
function _mint(address account_, uint256 amount_) internal {
}
function burn(uint256 amount_) public override onlyOwner {
}
function _burn(address account_, uint256 amount_) internal {
}
function _approve(
address owner_,
address spender_,
uint256 amount_
) internal virtual {
}
modifier onlyOwner() {
}
modifier initializer() {
require(<FILL_ME>)
_state.initialized = true;
_;
}
}
| !_state.initialized,"Already initialized" | 450,389 | !_state.initialized |
"D" | //SPDX-License-Identifier: BSL
pragma solidity ^0.7.6;
pragma abicoder v2;
// contracts
import "@openzeppelin/contracts/utils/SafeCast.sol";
import "../base/StrategyBase.sol";
// libraries
import "../libraries/LiquidityHelper.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// interfaces
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol";
import "../interfaces/ISwapProxy.sol";
contract UniswapV3LiquidityManager is StrategyBase, ReentrancyGuard, IUniswapV3MintCallback {
using SafeMath for uint256;
using SafeCast for uint256;
using SafeERC20 for IERC20;
event Sync(uint256 reserve0, uint256 reserve1);
event Swap(uint256 amountIn, uint256 amountOut, bool _zeroForOne);
event FeesClaim(address indexed strategy, uint256 amount0, uint256 amount1);
struct MintCallbackData {
address payer;
IUniswapV3Pool pool;
}
// to handle stake too deep error inside swap function
struct LocalVariables_Balances {
uint256 tokenInBalBefore;
uint256 tokenOutBalBefore;
uint256 tokenInBalAfter;
uint256 tokenOutBalAfter;
uint256 shareSupplyBefore;
}
/**
* @notice Mints liquidity from V3 Pool
* @param _tickLower Lower tick
* @param _tickUpper Upper tick
* @param _amount0 Amount of token0
* @param _amount1 Amount of token1
* @param _payer Address which is adding the liquidity
* @return amount0 Amount of token0 deployed to the pool
* @return amount1 Amount of token1 deployed to the pool
*/
function mintLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal returns (uint256 amount0, uint256 amount1) {
require(<FILL_ME>)
uint128 liquidity = LiquidityHelper.getLiquidityForAmounts(pool, _tickLower, _tickUpper, _amount0, _amount1);
// add liquidity to Uniswap pool
(amount0, amount1) = pool.mint(
address(this),
_tickLower,
_tickUpper,
liquidity,
abi.encode(MintCallbackData({payer: _payer, pool: pool}))
);
}
/**
* @notice Burns liquidity in the given range
* @param _tickLower Lower Tick
* @param _tickUpper Upper Tick
* @param _shares The amount of liquidity to be burned based on shares
* @param _currentLiquidity Liquidity to be burned
*/
function burnLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _shares,
uint128 _currentLiquidity
)
internal
returns (
uint256 tokensBurned0,
uint256 tokensBurned1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Splits and stores the performance feees in the local variables
* @param _fee0 Amount of accumulated fee for token0
* @param _fee1 Amount of accumulated fee for token1
*/
function addPerformanceFees(uint256 _fee0, uint256 _fee1) internal {
}
/**
* @notice Burns all the liquidity and collects fees
*/
function burnAllLiquidity() internal {
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
* @return amount0 Amount of token0's liquidity burned
* @return amount1 Amount of token1's liquidity burned
* @return fee0 Fee of token0 accumulated in the position which is being burned
* @return fee1 Fee of token1 accumulated in the position which is being burned
*/
function burnLiquiditySingle(uint256 _tickIndex)
public
nonReentrant
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
*/
function _burnLiquiditySingle(uint256 _tickIndex)
internal
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Swap the funds to 1Inch
* @param zeroToOne swap direction - true if swapping token0 to token1 else false
* @param amountIn amount of token to swap
* @param isOneInchSwap true if swap is happening from one inch
* @param data Swap data to perform exchange from 1inch
*/
function swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) public nonReentrant {
}
/**
* @notice Swap the funds to 1Inch
* @param data Swap data to perform exchange from 1inch
*/
function _swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) internal {
}
/**
* @dev Callback for Uniswap V3 pool.
*/
function uniswapV3MintCallback(
uint256 amount0,
uint256 amount1,
bytes calldata data
) external override {
}
/**
* @notice Get's assets under management with realtime fees
* @param _includeFee Whether to include pool fees in AUM or not. (passing true will also collect fees from pool)
* @param amount0 Total AUM of token0 including the fees ( if _includeFee is passed true)
* @param amount1 Total AUM of token1 including the fees ( if _includeFee is passed true)
* @param totalFee0 Total fee of token0 including the fees ( if _includeFee is passed true)
* @param totalFee1 Total fee of token1 including the fees ( if _includeFee is passed true)
*/
function getAUMWithFees(bool _includeFee)
external
returns (
uint256 amount0,
uint256 amount1,
uint256 totalFee0,
uint256 totalFee1
)
{
}
// force balances to match reserves
function skim(address to) external {
}
// force reserves to match balances
function sync() external {
}
}
| !onlyHasDeviation(),"D" | 450,459 | !onlyHasDeviation() |
"N" | //SPDX-License-Identifier: BSL
pragma solidity ^0.7.6;
pragma abicoder v2;
// contracts
import "@openzeppelin/contracts/utils/SafeCast.sol";
import "../base/StrategyBase.sol";
// libraries
import "../libraries/LiquidityHelper.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// interfaces
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol";
import "../interfaces/ISwapProxy.sol";
contract UniswapV3LiquidityManager is StrategyBase, ReentrancyGuard, IUniswapV3MintCallback {
using SafeMath for uint256;
using SafeCast for uint256;
using SafeERC20 for IERC20;
event Sync(uint256 reserve0, uint256 reserve1);
event Swap(uint256 amountIn, uint256 amountOut, bool _zeroForOne);
event FeesClaim(address indexed strategy, uint256 amount0, uint256 amount1);
struct MintCallbackData {
address payer;
IUniswapV3Pool pool;
}
// to handle stake too deep error inside swap function
struct LocalVariables_Balances {
uint256 tokenInBalBefore;
uint256 tokenOutBalBefore;
uint256 tokenInBalAfter;
uint256 tokenOutBalAfter;
uint256 shareSupplyBefore;
}
/**
* @notice Mints liquidity from V3 Pool
* @param _tickLower Lower tick
* @param _tickUpper Upper tick
* @param _amount0 Amount of token0
* @param _amount1 Amount of token1
* @param _payer Address which is adding the liquidity
* @return amount0 Amount of token0 deployed to the pool
* @return amount1 Amount of token1 deployed to the pool
*/
function mintLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal returns (uint256 amount0, uint256 amount1) {
}
/**
* @notice Burns liquidity in the given range
* @param _tickLower Lower Tick
* @param _tickUpper Upper Tick
* @param _shares The amount of liquidity to be burned based on shares
* @param _currentLiquidity Liquidity to be burned
*/
function burnLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _shares,
uint128 _currentLiquidity
)
internal
returns (
uint256 tokensBurned0,
uint256 tokensBurned1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Splits and stores the performance feees in the local variables
* @param _fee0 Amount of accumulated fee for token0
* @param _fee1 Amount of accumulated fee for token1
*/
function addPerformanceFees(uint256 _fee0, uint256 _fee1) internal {
}
/**
* @notice Burns all the liquidity and collects fees
*/
function burnAllLiquidity() internal {
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
* @return amount0 Amount of token0's liquidity burned
* @return amount1 Amount of token1's liquidity burned
* @return fee0 Fee of token0 accumulated in the position which is being burned
* @return fee1 Fee of token1 accumulated in the position which is being burned
*/
function burnLiquiditySingle(uint256 _tickIndex)
public
nonReentrant
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
require(!onlyHasDeviation(), "D");
require(<FILL_ME>)
(amount0, amount1, fee0, fee1) = _burnLiquiditySingle(_tickIndex);
// shift the index element at last of array
ticks[_tickIndex] = ticks[ticks.length - 1];
// remove last element
ticks.pop();
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
*/
function _burnLiquiditySingle(uint256 _tickIndex)
internal
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Swap the funds to 1Inch
* @param zeroToOne swap direction - true if swapping token0 to token1 else false
* @param amountIn amount of token to swap
* @param isOneInchSwap true if swap is happening from one inch
* @param data Swap data to perform exchange from 1inch
*/
function swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) public nonReentrant {
}
/**
* @notice Swap the funds to 1Inch
* @param data Swap data to perform exchange from 1inch
*/
function _swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) internal {
}
/**
* @dev Callback for Uniswap V3 pool.
*/
function uniswapV3MintCallback(
uint256 amount0,
uint256 amount1,
bytes calldata data
) external override {
}
/**
* @notice Get's assets under management with realtime fees
* @param _includeFee Whether to include pool fees in AUM or not. (passing true will also collect fees from pool)
* @param amount0 Total AUM of token0 including the fees ( if _includeFee is passed true)
* @param amount1 Total AUM of token1 including the fees ( if _includeFee is passed true)
* @param totalFee0 Total fee of token0 including the fees ( if _includeFee is passed true)
* @param totalFee1 Total fee of token1 including the fees ( if _includeFee is passed true)
*/
function getAUMWithFees(bool _includeFee)
external
returns (
uint256 amount0,
uint256 amount1,
uint256 totalFee0,
uint256 totalFee1
)
{
}
// force balances to match reserves
function skim(address to) external {
}
// force reserves to match balances
function sync() external {
}
}
| manager.isAllowedToBurn(msg.sender),"N" | 450,459 | manager.isAllowedToBurn(msg.sender) |
"N" | //SPDX-License-Identifier: BSL
pragma solidity ^0.7.6;
pragma abicoder v2;
// contracts
import "@openzeppelin/contracts/utils/SafeCast.sol";
import "../base/StrategyBase.sol";
// libraries
import "../libraries/LiquidityHelper.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// interfaces
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol";
import "../interfaces/ISwapProxy.sol";
contract UniswapV3LiquidityManager is StrategyBase, ReentrancyGuard, IUniswapV3MintCallback {
using SafeMath for uint256;
using SafeCast for uint256;
using SafeERC20 for IERC20;
event Sync(uint256 reserve0, uint256 reserve1);
event Swap(uint256 amountIn, uint256 amountOut, bool _zeroForOne);
event FeesClaim(address indexed strategy, uint256 amount0, uint256 amount1);
struct MintCallbackData {
address payer;
IUniswapV3Pool pool;
}
// to handle stake too deep error inside swap function
struct LocalVariables_Balances {
uint256 tokenInBalBefore;
uint256 tokenOutBalBefore;
uint256 tokenInBalAfter;
uint256 tokenOutBalAfter;
uint256 shareSupplyBefore;
}
/**
* @notice Mints liquidity from V3 Pool
* @param _tickLower Lower tick
* @param _tickUpper Upper tick
* @param _amount0 Amount of token0
* @param _amount1 Amount of token1
* @param _payer Address which is adding the liquidity
* @return amount0 Amount of token0 deployed to the pool
* @return amount1 Amount of token1 deployed to the pool
*/
function mintLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal returns (uint256 amount0, uint256 amount1) {
}
/**
* @notice Burns liquidity in the given range
* @param _tickLower Lower Tick
* @param _tickUpper Upper Tick
* @param _shares The amount of liquidity to be burned based on shares
* @param _currentLiquidity Liquidity to be burned
*/
function burnLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _shares,
uint128 _currentLiquidity
)
internal
returns (
uint256 tokensBurned0,
uint256 tokensBurned1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Splits and stores the performance feees in the local variables
* @param _fee0 Amount of accumulated fee for token0
* @param _fee1 Amount of accumulated fee for token1
*/
function addPerformanceFees(uint256 _fee0, uint256 _fee1) internal {
}
/**
* @notice Burns all the liquidity and collects fees
*/
function burnAllLiquidity() internal {
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
* @return amount0 Amount of token0's liquidity burned
* @return amount1 Amount of token1's liquidity burned
* @return fee0 Fee of token0 accumulated in the position which is being burned
* @return fee1 Fee of token1 accumulated in the position which is being burned
*/
function burnLiquiditySingle(uint256 _tickIndex)
public
nonReentrant
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
*/
function _burnLiquiditySingle(uint256 _tickIndex)
internal
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Swap the funds to 1Inch
* @param zeroToOne swap direction - true if swapping token0 to token1 else false
* @param amountIn amount of token to swap
* @param isOneInchSwap true if swap is happening from one inch
* @param data Swap data to perform exchange from 1inch
*/
function swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) public nonReentrant {
require(<FILL_ME>)
require(!onlyValidStrategy(), "DL");
_swap(zeroToOne, amountIn, isOneInchSwap, data);
}
/**
* @notice Swap the funds to 1Inch
* @param data Swap data to perform exchange from 1inch
*/
function _swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) internal {
}
/**
* @dev Callback for Uniswap V3 pool.
*/
function uniswapV3MintCallback(
uint256 amount0,
uint256 amount1,
bytes calldata data
) external override {
}
/**
* @notice Get's assets under management with realtime fees
* @param _includeFee Whether to include pool fees in AUM or not. (passing true will also collect fees from pool)
* @param amount0 Total AUM of token0 including the fees ( if _includeFee is passed true)
* @param amount1 Total AUM of token1 including the fees ( if _includeFee is passed true)
* @param totalFee0 Total fee of token0 including the fees ( if _includeFee is passed true)
* @param totalFee1 Total fee of token1 including the fees ( if _includeFee is passed true)
*/
function getAUMWithFees(bool _includeFee)
external
returns (
uint256 amount0,
uint256 amount1,
uint256 totalFee0,
uint256 totalFee1
)
{
}
// force balances to match reserves
function skim(address to) external {
}
// force reserves to match balances
function sync() external {
}
}
| onlyOperator(),"N" | 450,459 | onlyOperator() |
"DL" | //SPDX-License-Identifier: BSL
pragma solidity ^0.7.6;
pragma abicoder v2;
// contracts
import "@openzeppelin/contracts/utils/SafeCast.sol";
import "../base/StrategyBase.sol";
// libraries
import "../libraries/LiquidityHelper.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// interfaces
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol";
import "../interfaces/ISwapProxy.sol";
contract UniswapV3LiquidityManager is StrategyBase, ReentrancyGuard, IUniswapV3MintCallback {
using SafeMath for uint256;
using SafeCast for uint256;
using SafeERC20 for IERC20;
event Sync(uint256 reserve0, uint256 reserve1);
event Swap(uint256 amountIn, uint256 amountOut, bool _zeroForOne);
event FeesClaim(address indexed strategy, uint256 amount0, uint256 amount1);
struct MintCallbackData {
address payer;
IUniswapV3Pool pool;
}
// to handle stake too deep error inside swap function
struct LocalVariables_Balances {
uint256 tokenInBalBefore;
uint256 tokenOutBalBefore;
uint256 tokenInBalAfter;
uint256 tokenOutBalAfter;
uint256 shareSupplyBefore;
}
/**
* @notice Mints liquidity from V3 Pool
* @param _tickLower Lower tick
* @param _tickUpper Upper tick
* @param _amount0 Amount of token0
* @param _amount1 Amount of token1
* @param _payer Address which is adding the liquidity
* @return amount0 Amount of token0 deployed to the pool
* @return amount1 Amount of token1 deployed to the pool
*/
function mintLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal returns (uint256 amount0, uint256 amount1) {
}
/**
* @notice Burns liquidity in the given range
* @param _tickLower Lower Tick
* @param _tickUpper Upper Tick
* @param _shares The amount of liquidity to be burned based on shares
* @param _currentLiquidity Liquidity to be burned
*/
function burnLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _shares,
uint128 _currentLiquidity
)
internal
returns (
uint256 tokensBurned0,
uint256 tokensBurned1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Splits and stores the performance feees in the local variables
* @param _fee0 Amount of accumulated fee for token0
* @param _fee1 Amount of accumulated fee for token1
*/
function addPerformanceFees(uint256 _fee0, uint256 _fee1) internal {
}
/**
* @notice Burns all the liquidity and collects fees
*/
function burnAllLiquidity() internal {
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
* @return amount0 Amount of token0's liquidity burned
* @return amount1 Amount of token1's liquidity burned
* @return fee0 Fee of token0 accumulated in the position which is being burned
* @return fee1 Fee of token1 accumulated in the position which is being burned
*/
function burnLiquiditySingle(uint256 _tickIndex)
public
nonReentrant
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
*/
function _burnLiquiditySingle(uint256 _tickIndex)
internal
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Swap the funds to 1Inch
* @param zeroToOne swap direction - true if swapping token0 to token1 else false
* @param amountIn amount of token to swap
* @param isOneInchSwap true if swap is happening from one inch
* @param data Swap data to perform exchange from 1inch
*/
function swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) public nonReentrant {
require(onlyOperator(), "N");
require(<FILL_ME>)
_swap(zeroToOne, amountIn, isOneInchSwap, data);
}
/**
* @notice Swap the funds to 1Inch
* @param data Swap data to perform exchange from 1inch
*/
function _swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) internal {
}
/**
* @dev Callback for Uniswap V3 pool.
*/
function uniswapV3MintCallback(
uint256 amount0,
uint256 amount1,
bytes calldata data
) external override {
}
/**
* @notice Get's assets under management with realtime fees
* @param _includeFee Whether to include pool fees in AUM or not. (passing true will also collect fees from pool)
* @param amount0 Total AUM of token0 including the fees ( if _includeFee is passed true)
* @param amount1 Total AUM of token1 including the fees ( if _includeFee is passed true)
* @param totalFee0 Total fee of token0 including the fees ( if _includeFee is passed true)
* @param totalFee1 Total fee of token1 including the fees ( if _includeFee is passed true)
*/
function getAUMWithFees(bool _includeFee)
external
returns (
uint256 amount0,
uint256 amount1,
uint256 totalFee0,
uint256 totalFee1
)
{
}
// force balances to match reserves
function skim(address to) external {
}
// force reserves to match balances
function sync() external {
}
}
| !onlyValidStrategy(),"DL" | 450,459 | !onlyValidStrategy() |
"S" | //SPDX-License-Identifier: BSL
pragma solidity ^0.7.6;
pragma abicoder v2;
// contracts
import "@openzeppelin/contracts/utils/SafeCast.sol";
import "../base/StrategyBase.sol";
// libraries
import "../libraries/LiquidityHelper.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// interfaces
import "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3MintCallback.sol";
import "../interfaces/ISwapProxy.sol";
contract UniswapV3LiquidityManager is StrategyBase, ReentrancyGuard, IUniswapV3MintCallback {
using SafeMath for uint256;
using SafeCast for uint256;
using SafeERC20 for IERC20;
event Sync(uint256 reserve0, uint256 reserve1);
event Swap(uint256 amountIn, uint256 amountOut, bool _zeroForOne);
event FeesClaim(address indexed strategy, uint256 amount0, uint256 amount1);
struct MintCallbackData {
address payer;
IUniswapV3Pool pool;
}
// to handle stake too deep error inside swap function
struct LocalVariables_Balances {
uint256 tokenInBalBefore;
uint256 tokenOutBalBefore;
uint256 tokenInBalAfter;
uint256 tokenOutBalAfter;
uint256 shareSupplyBefore;
}
/**
* @notice Mints liquidity from V3 Pool
* @param _tickLower Lower tick
* @param _tickUpper Upper tick
* @param _amount0 Amount of token0
* @param _amount1 Amount of token1
* @param _payer Address which is adding the liquidity
* @return amount0 Amount of token0 deployed to the pool
* @return amount1 Amount of token1 deployed to the pool
*/
function mintLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _amount0,
uint256 _amount1,
address _payer
) internal returns (uint256 amount0, uint256 amount1) {
}
/**
* @notice Burns liquidity in the given range
* @param _tickLower Lower Tick
* @param _tickUpper Upper Tick
* @param _shares The amount of liquidity to be burned based on shares
* @param _currentLiquidity Liquidity to be burned
*/
function burnLiquidity(
int24 _tickLower,
int24 _tickUpper,
uint256 _shares,
uint128 _currentLiquidity
)
internal
returns (
uint256 tokensBurned0,
uint256 tokensBurned1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Splits and stores the performance feees in the local variables
* @param _fee0 Amount of accumulated fee for token0
* @param _fee1 Amount of accumulated fee for token1
*/
function addPerformanceFees(uint256 _fee0, uint256 _fee1) internal {
}
/**
* @notice Burns all the liquidity and collects fees
*/
function burnAllLiquidity() internal {
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
* @return amount0 Amount of token0's liquidity burned
* @return amount1 Amount of token1's liquidity burned
* @return fee0 Fee of token0 accumulated in the position which is being burned
* @return fee1 Fee of token1 accumulated in the position which is being burned
*/
function burnLiquiditySingle(uint256 _tickIndex)
public
nonReentrant
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Burn liquidity from specific tick
* @param _tickIndex Index of tick which needs to be burned
*/
function _burnLiquiditySingle(uint256 _tickIndex)
internal
returns (
uint256 amount0,
uint256 amount1,
uint256 fee0,
uint256 fee1
)
{
}
/**
* @notice Swap the funds to 1Inch
* @param zeroToOne swap direction - true if swapping token0 to token1 else false
* @param amountIn amount of token to swap
* @param isOneInchSwap true if swap is happening from one inch
* @param data Swap data to perform exchange from 1inch
*/
function swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) public nonReentrant {
}
/**
* @notice Swap the funds to 1Inch
* @param data Swap data to perform exchange from 1inch
*/
function _swap(bool zeroToOne, uint256 amountIn, bool isOneInchSwap, bytes calldata data) internal {
require(!onlyHasDeviation(), "D");
LocalVariables_Balances memory balances;
address swapProxy = factory.swapProxy();
IERC20 srcToken;
IERC20 dstToken;
if (zeroToOne) {
token0.safeIncreaseAllowance(swapProxy, amountIn);
srcToken = token0;
dstToken = token1;
} else {
token1.safeIncreaseAllowance(swapProxy, amountIn);
srcToken = token1;
dstToken = token0;
}
balances.tokenInBalBefore = srcToken.balanceOf(address(this));
balances.tokenOutBalBefore = dstToken.balanceOf(address(this));
balances.shareSupplyBefore = totalSupply();
if(isOneInchSwap){
ISwapProxy(swapProxy).aggregatorSwap(data);
} else {
// Interact with 1inch through contract call with data
(bool success, bytes memory returnData) = address(swapProxy).call(data);
// Verify return status and data
if (!success) {
uint256 length = returnData.length;
if (length < 68) {
// If the returnData length is less than 68, then the transaction failed silently.
revert("swap");
} else {
// Look for revert reason and bubble it up if present
uint256 t;
assembly {
returnData := add(returnData, 4)
t := mload(returnData) // Save the content of the length slot
mstore(returnData, sub(length, 4)) // Set proper length
}
string memory reason = abi.decode(returnData, (string));
assembly {
mstore(returnData, t) // Restore the content of the length slot
}
revert(reason);
}
}
}
require(balances.shareSupplyBefore == totalSupply());
balances.tokenInBalAfter = srcToken.balanceOf(address(this));
balances.tokenOutBalAfter = dstToken.balanceOf(address(this));
uint256 amountInFinal = balances.tokenInBalBefore.sub(balances.tokenInBalAfter);
uint256 amountOutFinal = balances.tokenOutBalAfter.sub(balances.tokenOutBalBefore);
// revoke approval after swap & update reserves
if (zeroToOne) {
token0.safeApprove(swapProxy, 0);
reserve0 = reserve0.sub(amountInFinal);
reserve1 = reserve1.add(amountOutFinal);
} else {
token1.safeApprove(swapProxy, 0);
reserve0 = reserve0.add(amountOutFinal);
reserve1 = reserve1.sub(amountInFinal);
}
manager.increamentSwapCounter();
require(<FILL_ME>)
}
/**
* @dev Callback for Uniswap V3 pool.
*/
function uniswapV3MintCallback(
uint256 amount0,
uint256 amount1,
bytes calldata data
) external override {
}
/**
* @notice Get's assets under management with realtime fees
* @param _includeFee Whether to include pool fees in AUM or not. (passing true will also collect fees from pool)
* @param amount0 Total AUM of token0 including the fees ( if _includeFee is passed true)
* @param amount1 Total AUM of token1 including the fees ( if _includeFee is passed true)
* @param totalFee0 Total fee of token0 including the fees ( if _includeFee is passed true)
* @param totalFee1 Total fee of token1 including the fees ( if _includeFee is passed true)
*/
function getAUMWithFees(bool _includeFee)
external
returns (
uint256 amount0,
uint256 amount1,
uint256 totalFee0,
uint256 totalFee1
)
{
}
// force balances to match reserves
function skim(address to) external {
}
// force reserves to match balances
function sync() external {
}
}
| OracleLibrary.allowSwap(pool,factory,amountInFinal,amountOutFinal,address(srcToken),address(dstToken),[usdAsBase[0],usdAsBase[1]]),"S" | 450,459 | OracleLibrary.allowSwap(pool,factory,amountInFinal,amountOutFinal,address(srcToken),address(dstToken),[usdAsBase[0],usdAsBase[1]]) |
"This address has already sent an Acolyte." | // SPDX-License-Identifier: WAGDIE
//
// โ๐ซ ๐๐ฌ๐ฏ๐ฐ๐๐จ๐ข๐ซ ๐๐๐ซ๐ก๐ฐ, ๐ด๐ฅ๐ข๐ฏ๐ข ๐ฐ๐ฅ๐๐ก๐ฌ๐ด๐ฐ ๐ฉ๐ฆ๐ข,
// ๐๐ฅ๐ข ๐ฑ๐๐ฉ๐ข ๐ฌ๐ฃ ๐๐ฐ๐ฑ๐๐ฏ๐ฌ๐ฑ๐ฅ ๐ญ๐ฆ๐ข๐ฏ๐ ๐ข๐ฐ ๐ฐ๐จ๐ถ.
// ๐
๐ฌ๐ซ๐ข๐ฐ ๐ฌ๐ฃ ๐ฏ๐ข๐ก, ๐๐ซ๐ก ๐ฅ๐ข๐๐ฏ๐ฑ ๐๐๐ฉ๐๐ท๐ข,
// โ๐ฆ๐ฐ ๐ฎ๐ฒ๐ข๐ฐ๐ฑ, ๐ ๐ฏ๐ข๐ฉ๐ข๐ซ๐ฑ๐ฉ๐ข๐ฐ๐ฐ, ๐๐ฒ๐ฏ๐ซ๐ฆ๐ซ๐ค ๐ฏ๐๐ค๐ข.
//
//
// ๐๐ค๐๐ฆ๐ซ๐ฐ๐ฑ ๐๐ฅ๐ข ๐๐ฉ๐ฒ๐ฑ๐ฑ๐ฌ๐ซ, ๐ ๐๐ข๐๐ฐ๐ฑ๐ฉ๐ถ ๐ช๐ฆ๐ค๐ฅ๐ฑ,
// ๐๐ข๐๐ฑ๐ฅ๐ข๐ฏ๐ฐ ๐๐ซ๐ค๐ข๐ฉ๐ฆ๐ , ๐๐ฒ๐ฑ ๐ฃ๐๐ฉ๐ฐ๐ข ๐ฆ๐ซ ๐ฉ๐ฆ๐ค๐ฅ๐ฑ.
// ๐๐ฅ๐ฏ๐ฌ๐ฒ๐ค๐ฅ ๐๐๐ฑ๐ฑ๐ฉ๐ข, ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ฃ๐ฒ๐ฏ๐ถ ๐ฏ๐ฌ๐๐ฏ๐ข๐ก,
// ๐๐ฑ๐ข๐ข๐ฉ ๐๐ซ๐ก ๐ฅ๐ฆ๐ก๐ข, ๐ ๐๐ฒ๐ฏ๐ฉ๐ฌ ๐ฐ๐ ๐ฌ๐ฏ๐ซ๐ข๐ก.
//
//
// ๐๐ด๐๐ฉ๐ฉ๐ฌ๐ด๐ข๐ก ๐ด๐ฅ๐ฌ๐ฉ๐ข ๐๐ถ ๐๐ฉ๐ฒ๐ฑ๐ฑ๐ฌ๐ซ'๐ฐ ๐ช๐๐ด,
// ๐๐ฅ๐ข ๐ก๐ข๐ช๐ฌ๐ซ'๐ฐ ๐ญ๐ฉ๐๐ซ ๐ฑ๐ฌ ๐ฃ๐๐ฑ๐๐ฉ ๐ฃ๐ฉ๐๐ด.
// ๐๐ ๐ฌ๐ฉ๐ถ๐ฑ๐ข๐ฐ ๐ด๐ฅ๐ฆ๐ฐ๐ญ๐ข๐ฏ ๐ฆ๐ซ ๐ซ๐ฆ๐ค๐ฅ๐ฑ'๐ฐ ๐ข๐ช๐๐ฏ๐๐ ๐ข,
// โญ๐๐ฏ๐ฏ๐ถ๐ฆ๐ซ๐ค ๐ฃ๐ฌ๐ฏ๐ฑ๐ฅ ๐ฅ๐ฆ๐ฐ ๐ฒ๐ซ๐ฃ๐ฒ๐ฉ๐ฃ๐ฆ๐ฉ๐ฉ๐ข๐ก ๐ ๐ฅ๐๐ฐ๐ข.
//
//
// โ๐ซ ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ฅ๐ข๐๐ฏ๐ฑ๐ฐ, ๐ฅ๐ฆ๐ฐ ๐ฃ๐ฒ๐ฏ๐ถ ๐ก๐ฌ๐ฑ๐ฅ ๐๐ฒ๐ฏ๐ซ,
// ๐๐ฐ๐ฑ๐๐ฏ๐ฌ๐ฑ๐ฅ'๐ฐ ๐ณ๐ข๐ซ๐ค๐ข๐๐ซ๐ ๐ข, ๐ฑ๐ฅ๐ข๐ถ ๐ฐ๐ข๐ข๐จ ๐ฑ๐ฌ ๐ข๐๐ฏ๐ซ.
// โ๐ซ ๐ด๐ฅ๐ฆ๐ฐ๐ญ๐ข๐ฏ๐ฐ, ๐ฆ๐ซ ๐ฐ๐ฅ๐๐ก๐ฌ๐ด๐ฐ, ๐ฆ๐ซ ๐ฎ๐ฒ๐ฆ๐ข๐ฑ ๐ฌ๐ฃ ๐ซ๐ฆ๐ค๐ฅ๐ฑ,
// โ๐ฆ๐ฐ ๐ฐ๐ญ๐ฆ๐ฏ๐ฆ๐ฑ ๐ข๐ซ๐ก๐ฒ๐ฏ๐ข๐ฐ, ๐ฆ๐ซ ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ด๐ฆ๐ฉ๐ฉ ๐ฑ๐ฌ ๐ฃ๐ฆ๐ค๐ฅ๐ฑ.
//
//
pragma solidity ^0.8.0;
interface IERC721 {
function transferFrom(address from, address to, uint256 tokenId) external;
function transfer(address to, uint256 tokenId) external;
}
interface IConcord {
function bestowTokensMany(
address[] calldata _to,
uint256[] calldata _tokens,
uint256[] calldata _amounts
) external;
}
contract AstarothsVengeance {
address constant burnAddress =
address(0x000000000000000000000000000000000000dEaD);
address constant wagdieAuthor =
address(0x8d2Eb1c6Ab5D87C5091f09fFE4a5ed31B1D9CF71);
bool public vengeanceAchieved = false;
struct Acolytes {
uint256 wagdieTokenId;
uint256 acolyteTokenId;
bool vengeanceAgreed;
}
mapping(address => Acolytes) private submissions;
address[] private acolyteAddresses;
IERC721 public wagdieContract;
IERC721 public acolyteContract;
IConcord public concordContract;
constructor() {
}
// Acolytes arrive to demand vengeance for Astaroth
function sendAcolyte(uint256 wagdieTokenId, uint256 acolyteTokenId) public {
require(<FILL_ME>)
require(acolyteTokenId >= 31 && acolyteTokenId <= 43,"This AKIB Hero is not an Acolyte of Astaroth.");
require(!vengeanceAchieved, "Cannot join the pact, after vengeance has been achieved.");
wagdieContract.transferFrom(msg.sender, address(this), wagdieTokenId);
acolyteContract.transferFrom(msg.sender, address(this), acolyteTokenId);
// Upon entry, arrive with a sense of unfulfilled vengeance
acolyteAddresses.push(msg.sender);
submissions[msg.sender] = Acolytes(
wagdieTokenId,
acolyteTokenId,
false
);
}
// Once Vengeance has been granted and agreed, Acolytes may return
function returnAcolyte() public {
}
// The Two may slay random Acolytes
function slayAcolyte() public {
}
// The Two grant an opportunity at vengeance
function grantVengeance() public {
}
// Individual Acolyte agrees to vengeance
function agreeVengeance() public {
}
// Random number generator
function _getPseudoRandomNumber() private view returns (uint256) {
}
// Locate address index within array (for removals)
function _findAddressIndex(address addr) private view returns (uint256) {
}
// Remove address from array by index (does not affect memory)
function _removeAddressFromSubmitters(uint256 index) private {
}
}
| submissions[msg.sender].wagdieTokenId==0&&submissions[msg.sender].acolyteTokenId==0,"This address has already sent an Acolyte." | 450,637 | submissions[msg.sender].wagdieTokenId==0&&submissions[msg.sender].acolyteTokenId==0 |
"Cannot join the pact, after vengeance has been achieved." | // SPDX-License-Identifier: WAGDIE
//
// โ๐ซ ๐๐ฌ๐ฏ๐ฐ๐๐จ๐ข๐ซ ๐๐๐ซ๐ก๐ฐ, ๐ด๐ฅ๐ข๐ฏ๐ข ๐ฐ๐ฅ๐๐ก๐ฌ๐ด๐ฐ ๐ฉ๐ฆ๐ข,
// ๐๐ฅ๐ข ๐ฑ๐๐ฉ๐ข ๐ฌ๐ฃ ๐๐ฐ๐ฑ๐๐ฏ๐ฌ๐ฑ๐ฅ ๐ญ๐ฆ๐ข๐ฏ๐ ๐ข๐ฐ ๐ฐ๐จ๐ถ.
// ๐
๐ฌ๐ซ๐ข๐ฐ ๐ฌ๐ฃ ๐ฏ๐ข๐ก, ๐๐ซ๐ก ๐ฅ๐ข๐๐ฏ๐ฑ ๐๐๐ฉ๐๐ท๐ข,
// โ๐ฆ๐ฐ ๐ฎ๐ฒ๐ข๐ฐ๐ฑ, ๐ ๐ฏ๐ข๐ฉ๐ข๐ซ๐ฑ๐ฉ๐ข๐ฐ๐ฐ, ๐๐ฒ๐ฏ๐ซ๐ฆ๐ซ๐ค ๐ฏ๐๐ค๐ข.
//
//
// ๐๐ค๐๐ฆ๐ซ๐ฐ๐ฑ ๐๐ฅ๐ข ๐๐ฉ๐ฒ๐ฑ๐ฑ๐ฌ๐ซ, ๐ ๐๐ข๐๐ฐ๐ฑ๐ฉ๐ถ ๐ช๐ฆ๐ค๐ฅ๐ฑ,
// ๐๐ข๐๐ฑ๐ฅ๐ข๐ฏ๐ฐ ๐๐ซ๐ค๐ข๐ฉ๐ฆ๐ , ๐๐ฒ๐ฑ ๐ฃ๐๐ฉ๐ฐ๐ข ๐ฆ๐ซ ๐ฉ๐ฆ๐ค๐ฅ๐ฑ.
// ๐๐ฅ๐ฏ๐ฌ๐ฒ๐ค๐ฅ ๐๐๐ฑ๐ฑ๐ฉ๐ข, ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ฃ๐ฒ๐ฏ๐ถ ๐ฏ๐ฌ๐๐ฏ๐ข๐ก,
// ๐๐ฑ๐ข๐ข๐ฉ ๐๐ซ๐ก ๐ฅ๐ฆ๐ก๐ข, ๐ ๐๐ฒ๐ฏ๐ฉ๐ฌ ๐ฐ๐ ๐ฌ๐ฏ๐ซ๐ข๐ก.
//
//
// ๐๐ด๐๐ฉ๐ฉ๐ฌ๐ด๐ข๐ก ๐ด๐ฅ๐ฌ๐ฉ๐ข ๐๐ถ ๐๐ฉ๐ฒ๐ฑ๐ฑ๐ฌ๐ซ'๐ฐ ๐ช๐๐ด,
// ๐๐ฅ๐ข ๐ก๐ข๐ช๐ฌ๐ซ'๐ฐ ๐ญ๐ฉ๐๐ซ ๐ฑ๐ฌ ๐ฃ๐๐ฑ๐๐ฉ ๐ฃ๐ฉ๐๐ด.
// ๐๐ ๐ฌ๐ฉ๐ถ๐ฑ๐ข๐ฐ ๐ด๐ฅ๐ฆ๐ฐ๐ญ๐ข๐ฏ ๐ฆ๐ซ ๐ซ๐ฆ๐ค๐ฅ๐ฑ'๐ฐ ๐ข๐ช๐๐ฏ๐๐ ๐ข,
// โญ๐๐ฏ๐ฏ๐ถ๐ฆ๐ซ๐ค ๐ฃ๐ฌ๐ฏ๐ฑ๐ฅ ๐ฅ๐ฆ๐ฐ ๐ฒ๐ซ๐ฃ๐ฒ๐ฉ๐ฃ๐ฆ๐ฉ๐ฉ๐ข๐ก ๐ ๐ฅ๐๐ฐ๐ข.
//
//
// โ๐ซ ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ฅ๐ข๐๐ฏ๐ฑ๐ฐ, ๐ฅ๐ฆ๐ฐ ๐ฃ๐ฒ๐ฏ๐ถ ๐ก๐ฌ๐ฑ๐ฅ ๐๐ฒ๐ฏ๐ซ,
// ๐๐ฐ๐ฑ๐๐ฏ๐ฌ๐ฑ๐ฅ'๐ฐ ๐ณ๐ข๐ซ๐ค๐ข๐๐ซ๐ ๐ข, ๐ฑ๐ฅ๐ข๐ถ ๐ฐ๐ข๐ข๐จ ๐ฑ๐ฌ ๐ข๐๐ฏ๐ซ.
// โ๐ซ ๐ด๐ฅ๐ฆ๐ฐ๐ญ๐ข๐ฏ๐ฐ, ๐ฆ๐ซ ๐ฐ๐ฅ๐๐ก๐ฌ๐ด๐ฐ, ๐ฆ๐ซ ๐ฎ๐ฒ๐ฆ๐ข๐ฑ ๐ฌ๐ฃ ๐ซ๐ฆ๐ค๐ฅ๐ฑ,
// โ๐ฆ๐ฐ ๐ฐ๐ญ๐ฆ๐ฏ๐ฆ๐ฑ ๐ข๐ซ๐ก๐ฒ๐ฏ๐ข๐ฐ, ๐ฆ๐ซ ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ด๐ฆ๐ฉ๐ฉ ๐ฑ๐ฌ ๐ฃ๐ฆ๐ค๐ฅ๐ฑ.
//
//
pragma solidity ^0.8.0;
interface IERC721 {
function transferFrom(address from, address to, uint256 tokenId) external;
function transfer(address to, uint256 tokenId) external;
}
interface IConcord {
function bestowTokensMany(
address[] calldata _to,
uint256[] calldata _tokens,
uint256[] calldata _amounts
) external;
}
contract AstarothsVengeance {
address constant burnAddress =
address(0x000000000000000000000000000000000000dEaD);
address constant wagdieAuthor =
address(0x8d2Eb1c6Ab5D87C5091f09fFE4a5ed31B1D9CF71);
bool public vengeanceAchieved = false;
struct Acolytes {
uint256 wagdieTokenId;
uint256 acolyteTokenId;
bool vengeanceAgreed;
}
mapping(address => Acolytes) private submissions;
address[] private acolyteAddresses;
IERC721 public wagdieContract;
IERC721 public acolyteContract;
IConcord public concordContract;
constructor() {
}
// Acolytes arrive to demand vengeance for Astaroth
function sendAcolyte(uint256 wagdieTokenId, uint256 acolyteTokenId) public {
require( submissions[msg.sender].wagdieTokenId == 0 && submissions[msg.sender].acolyteTokenId == 0, "This address has already sent an Acolyte." );
require(acolyteTokenId >= 31 && acolyteTokenId <= 43,"This AKIB Hero is not an Acolyte of Astaroth.");
require(<FILL_ME>)
wagdieContract.transferFrom(msg.sender, address(this), wagdieTokenId);
acolyteContract.transferFrom(msg.sender, address(this), acolyteTokenId);
// Upon entry, arrive with a sense of unfulfilled vengeance
acolyteAddresses.push(msg.sender);
submissions[msg.sender] = Acolytes(
wagdieTokenId,
acolyteTokenId,
false
);
}
// Once Vengeance has been granted and agreed, Acolytes may return
function returnAcolyte() public {
}
// The Two may slay random Acolytes
function slayAcolyte() public {
}
// The Two grant an opportunity at vengeance
function grantVengeance() public {
}
// Individual Acolyte agrees to vengeance
function agreeVengeance() public {
}
// Random number generator
function _getPseudoRandomNumber() private view returns (uint256) {
}
// Locate address index within array (for removals)
function _findAddressIndex(address addr) private view returns (uint256) {
}
// Remove address from array by index (does not affect memory)
function _removeAddressFromSubmitters(uint256 index) private {
}
}
| !vengeanceAchieved,"Cannot join the pact, after vengeance has been achieved." | 450,637 | !vengeanceAchieved |
"Not all Acolytes have agreed to vengeance." | // SPDX-License-Identifier: WAGDIE
//
// โ๐ซ ๐๐ฌ๐ฏ๐ฐ๐๐จ๐ข๐ซ ๐๐๐ซ๐ก๐ฐ, ๐ด๐ฅ๐ข๐ฏ๐ข ๐ฐ๐ฅ๐๐ก๐ฌ๐ด๐ฐ ๐ฉ๐ฆ๐ข,
// ๐๐ฅ๐ข ๐ฑ๐๐ฉ๐ข ๐ฌ๐ฃ ๐๐ฐ๐ฑ๐๐ฏ๐ฌ๐ฑ๐ฅ ๐ญ๐ฆ๐ข๐ฏ๐ ๐ข๐ฐ ๐ฐ๐จ๐ถ.
// ๐
๐ฌ๐ซ๐ข๐ฐ ๐ฌ๐ฃ ๐ฏ๐ข๐ก, ๐๐ซ๐ก ๐ฅ๐ข๐๐ฏ๐ฑ ๐๐๐ฉ๐๐ท๐ข,
// โ๐ฆ๐ฐ ๐ฎ๐ฒ๐ข๐ฐ๐ฑ, ๐ ๐ฏ๐ข๐ฉ๐ข๐ซ๐ฑ๐ฉ๐ข๐ฐ๐ฐ, ๐๐ฒ๐ฏ๐ซ๐ฆ๐ซ๐ค ๐ฏ๐๐ค๐ข.
//
//
// ๐๐ค๐๐ฆ๐ซ๐ฐ๐ฑ ๐๐ฅ๐ข ๐๐ฉ๐ฒ๐ฑ๐ฑ๐ฌ๐ซ, ๐ ๐๐ข๐๐ฐ๐ฑ๐ฉ๐ถ ๐ช๐ฆ๐ค๐ฅ๐ฑ,
// ๐๐ข๐๐ฑ๐ฅ๐ข๐ฏ๐ฐ ๐๐ซ๐ค๐ข๐ฉ๐ฆ๐ , ๐๐ฒ๐ฑ ๐ฃ๐๐ฉ๐ฐ๐ข ๐ฆ๐ซ ๐ฉ๐ฆ๐ค๐ฅ๐ฑ.
// ๐๐ฅ๐ฏ๐ฌ๐ฒ๐ค๐ฅ ๐๐๐ฑ๐ฑ๐ฉ๐ข, ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ฃ๐ฒ๐ฏ๐ถ ๐ฏ๐ฌ๐๐ฏ๐ข๐ก,
// ๐๐ฑ๐ข๐ข๐ฉ ๐๐ซ๐ก ๐ฅ๐ฆ๐ก๐ข, ๐ ๐๐ฒ๐ฏ๐ฉ๐ฌ ๐ฐ๐ ๐ฌ๐ฏ๐ซ๐ข๐ก.
//
//
// ๐๐ด๐๐ฉ๐ฉ๐ฌ๐ด๐ข๐ก ๐ด๐ฅ๐ฌ๐ฉ๐ข ๐๐ถ ๐๐ฉ๐ฒ๐ฑ๐ฑ๐ฌ๐ซ'๐ฐ ๐ช๐๐ด,
// ๐๐ฅ๐ข ๐ก๐ข๐ช๐ฌ๐ซ'๐ฐ ๐ญ๐ฉ๐๐ซ ๐ฑ๐ฌ ๐ฃ๐๐ฑ๐๐ฉ ๐ฃ๐ฉ๐๐ด.
// ๐๐ ๐ฌ๐ฉ๐ถ๐ฑ๐ข๐ฐ ๐ด๐ฅ๐ฆ๐ฐ๐ญ๐ข๐ฏ ๐ฆ๐ซ ๐ซ๐ฆ๐ค๐ฅ๐ฑ'๐ฐ ๐ข๐ช๐๐ฏ๐๐ ๐ข,
// โญ๐๐ฏ๐ฏ๐ถ๐ฆ๐ซ๐ค ๐ฃ๐ฌ๐ฏ๐ฑ๐ฅ ๐ฅ๐ฆ๐ฐ ๐ฒ๐ซ๐ฃ๐ฒ๐ฉ๐ฃ๐ฆ๐ฉ๐ฉ๐ข๐ก ๐ ๐ฅ๐๐ฐ๐ข.
//
//
// โ๐ซ ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ฅ๐ข๐๐ฏ๐ฑ๐ฐ, ๐ฅ๐ฆ๐ฐ ๐ฃ๐ฒ๐ฏ๐ถ ๐ก๐ฌ๐ฑ๐ฅ ๐๐ฒ๐ฏ๐ซ,
// ๐๐ฐ๐ฑ๐๐ฏ๐ฌ๐ฑ๐ฅ'๐ฐ ๐ณ๐ข๐ซ๐ค๐ข๐๐ซ๐ ๐ข, ๐ฑ๐ฅ๐ข๐ถ ๐ฐ๐ข๐ข๐จ ๐ฑ๐ฌ ๐ข๐๐ฏ๐ซ.
// โ๐ซ ๐ด๐ฅ๐ฆ๐ฐ๐ญ๐ข๐ฏ๐ฐ, ๐ฆ๐ซ ๐ฐ๐ฅ๐๐ก๐ฌ๐ด๐ฐ, ๐ฆ๐ซ ๐ฎ๐ฒ๐ฆ๐ข๐ฑ ๐ฌ๐ฃ ๐ซ๐ฆ๐ค๐ฅ๐ฑ,
// โ๐ฆ๐ฐ ๐ฐ๐ญ๐ฆ๐ฏ๐ฆ๐ฑ ๐ข๐ซ๐ก๐ฒ๐ฏ๐ข๐ฐ, ๐ฆ๐ซ ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ด๐ฆ๐ฉ๐ฉ ๐ฑ๐ฌ ๐ฃ๐ฆ๐ค๐ฅ๐ฑ.
//
//
pragma solidity ^0.8.0;
interface IERC721 {
function transferFrom(address from, address to, uint256 tokenId) external;
function transfer(address to, uint256 tokenId) external;
}
interface IConcord {
function bestowTokensMany(
address[] calldata _to,
uint256[] calldata _tokens,
uint256[] calldata _amounts
) external;
}
contract AstarothsVengeance {
address constant burnAddress =
address(0x000000000000000000000000000000000000dEaD);
address constant wagdieAuthor =
address(0x8d2Eb1c6Ab5D87C5091f09fFE4a5ed31B1D9CF71);
bool public vengeanceAchieved = false;
struct Acolytes {
uint256 wagdieTokenId;
uint256 acolyteTokenId;
bool vengeanceAgreed;
}
mapping(address => Acolytes) private submissions;
address[] private acolyteAddresses;
IERC721 public wagdieContract;
IERC721 public acolyteContract;
IConcord public concordContract;
constructor() {
}
// Acolytes arrive to demand vengeance for Astaroth
function sendAcolyte(uint256 wagdieTokenId, uint256 acolyteTokenId) public {
}
// Once Vengeance has been granted and agreed, Acolytes may return
function returnAcolyte() public {
require(vengeanceAchieved, "Vengeance has not yet been achieved.");
for (uint i = 0; i < acolyteAddresses.length; i++) {
require(<FILL_ME>)
}
Acolytes storage submission = submissions[msg.sender];
require(submission.wagdieTokenId > 0 && submission.acolyteTokenId > 0, "No Acolyte from this address is present.");
// Transfer the tokens back to the sender
wagdieContract.transfer(msg.sender, submission.wagdieTokenId);
acolyteContract.transfer(msg.sender, submission.acolyteTokenId);
// Remove the user's address from acolyteAddresses
_removeAddressFromSubmitters(_findAddressIndex(msg.sender));
}
// The Two may slay random Acolytes
function slayAcolyte() public {
}
// The Two grant an opportunity at vengeance
function grantVengeance() public {
}
// Individual Acolyte agrees to vengeance
function agreeVengeance() public {
}
// Random number generator
function _getPseudoRandomNumber() private view returns (uint256) {
}
// Locate address index within array (for removals)
function _findAddressIndex(address addr) private view returns (uint256) {
}
// Remove address from array by index (does not affect memory)
function _removeAddressFromSubmitters(uint256 index) private {
}
}
| submissions[acolyteAddresses[i]].vengeanceAgreed,"Not all Acolytes have agreed to vengeance." | 450,637 | submissions[acolyteAddresses[i]].vengeanceAgreed |
"No Acolyte from this address is present." | // SPDX-License-Identifier: WAGDIE
//
// โ๐ซ ๐๐ฌ๐ฏ๐ฐ๐๐จ๐ข๐ซ ๐๐๐ซ๐ก๐ฐ, ๐ด๐ฅ๐ข๐ฏ๐ข ๐ฐ๐ฅ๐๐ก๐ฌ๐ด๐ฐ ๐ฉ๐ฆ๐ข,
// ๐๐ฅ๐ข ๐ฑ๐๐ฉ๐ข ๐ฌ๐ฃ ๐๐ฐ๐ฑ๐๐ฏ๐ฌ๐ฑ๐ฅ ๐ญ๐ฆ๐ข๐ฏ๐ ๐ข๐ฐ ๐ฐ๐จ๐ถ.
// ๐
๐ฌ๐ซ๐ข๐ฐ ๐ฌ๐ฃ ๐ฏ๐ข๐ก, ๐๐ซ๐ก ๐ฅ๐ข๐๐ฏ๐ฑ ๐๐๐ฉ๐๐ท๐ข,
// โ๐ฆ๐ฐ ๐ฎ๐ฒ๐ข๐ฐ๐ฑ, ๐ ๐ฏ๐ข๐ฉ๐ข๐ซ๐ฑ๐ฉ๐ข๐ฐ๐ฐ, ๐๐ฒ๐ฏ๐ซ๐ฆ๐ซ๐ค ๐ฏ๐๐ค๐ข.
//
//
// ๐๐ค๐๐ฆ๐ซ๐ฐ๐ฑ ๐๐ฅ๐ข ๐๐ฉ๐ฒ๐ฑ๐ฑ๐ฌ๐ซ, ๐ ๐๐ข๐๐ฐ๐ฑ๐ฉ๐ถ ๐ช๐ฆ๐ค๐ฅ๐ฑ,
// ๐๐ข๐๐ฑ๐ฅ๐ข๐ฏ๐ฐ ๐๐ซ๐ค๐ข๐ฉ๐ฆ๐ , ๐๐ฒ๐ฑ ๐ฃ๐๐ฉ๐ฐ๐ข ๐ฆ๐ซ ๐ฉ๐ฆ๐ค๐ฅ๐ฑ.
// ๐๐ฅ๐ฏ๐ฌ๐ฒ๐ค๐ฅ ๐๐๐ฑ๐ฑ๐ฉ๐ข, ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ฃ๐ฒ๐ฏ๐ถ ๐ฏ๐ฌ๐๐ฏ๐ข๐ก,
// ๐๐ฑ๐ข๐ข๐ฉ ๐๐ซ๐ก ๐ฅ๐ฆ๐ก๐ข, ๐ ๐๐ฒ๐ฏ๐ฉ๐ฌ ๐ฐ๐ ๐ฌ๐ฏ๐ซ๐ข๐ก.
//
//
// ๐๐ด๐๐ฉ๐ฉ๐ฌ๐ด๐ข๐ก ๐ด๐ฅ๐ฌ๐ฉ๐ข ๐๐ถ ๐๐ฉ๐ฒ๐ฑ๐ฑ๐ฌ๐ซ'๐ฐ ๐ช๐๐ด,
// ๐๐ฅ๐ข ๐ก๐ข๐ช๐ฌ๐ซ'๐ฐ ๐ญ๐ฉ๐๐ซ ๐ฑ๐ฌ ๐ฃ๐๐ฑ๐๐ฉ ๐ฃ๐ฉ๐๐ด.
// ๐๐ ๐ฌ๐ฉ๐ถ๐ฑ๐ข๐ฐ ๐ด๐ฅ๐ฆ๐ฐ๐ญ๐ข๐ฏ ๐ฆ๐ซ ๐ซ๐ฆ๐ค๐ฅ๐ฑ'๐ฐ ๐ข๐ช๐๐ฏ๐๐ ๐ข,
// โญ๐๐ฏ๐ฏ๐ถ๐ฆ๐ซ๐ค ๐ฃ๐ฌ๐ฏ๐ฑ๐ฅ ๐ฅ๐ฆ๐ฐ ๐ฒ๐ซ๐ฃ๐ฒ๐ฉ๐ฃ๐ฆ๐ฉ๐ฉ๐ข๐ก ๐ ๐ฅ๐๐ฐ๐ข.
//
//
// โ๐ซ ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ฅ๐ข๐๐ฏ๐ฑ๐ฐ, ๐ฅ๐ฆ๐ฐ ๐ฃ๐ฒ๐ฏ๐ถ ๐ก๐ฌ๐ฑ๐ฅ ๐๐ฒ๐ฏ๐ซ,
// ๐๐ฐ๐ฑ๐๐ฏ๐ฌ๐ฑ๐ฅ'๐ฐ ๐ณ๐ข๐ซ๐ค๐ข๐๐ซ๐ ๐ข, ๐ฑ๐ฅ๐ข๐ถ ๐ฐ๐ข๐ข๐จ ๐ฑ๐ฌ ๐ข๐๐ฏ๐ซ.
// โ๐ซ ๐ด๐ฅ๐ฆ๐ฐ๐ญ๐ข๐ฏ๐ฐ, ๐ฆ๐ซ ๐ฐ๐ฅ๐๐ก๐ฌ๐ด๐ฐ, ๐ฆ๐ซ ๐ฎ๐ฒ๐ฆ๐ข๐ฑ ๐ฌ๐ฃ ๐ซ๐ฆ๐ค๐ฅ๐ฑ,
// โ๐ฆ๐ฐ ๐ฐ๐ญ๐ฆ๐ฏ๐ฆ๐ฑ ๐ข๐ซ๐ก๐ฒ๐ฏ๐ข๐ฐ, ๐ฆ๐ซ ๐ฑ๐ฅ๐ข๐ฆ๐ฏ ๐ด๐ฆ๐ฉ๐ฉ ๐ฑ๐ฌ ๐ฃ๐ฆ๐ค๐ฅ๐ฑ.
//
//
pragma solidity ^0.8.0;
interface IERC721 {
function transferFrom(address from, address to, uint256 tokenId) external;
function transfer(address to, uint256 tokenId) external;
}
interface IConcord {
function bestowTokensMany(
address[] calldata _to,
uint256[] calldata _tokens,
uint256[] calldata _amounts
) external;
}
contract AstarothsVengeance {
address constant burnAddress =
address(0x000000000000000000000000000000000000dEaD);
address constant wagdieAuthor =
address(0x8d2Eb1c6Ab5D87C5091f09fFE4a5ed31B1D9CF71);
bool public vengeanceAchieved = false;
struct Acolytes {
uint256 wagdieTokenId;
uint256 acolyteTokenId;
bool vengeanceAgreed;
}
mapping(address => Acolytes) private submissions;
address[] private acolyteAddresses;
IERC721 public wagdieContract;
IERC721 public acolyteContract;
IConcord public concordContract;
constructor() {
}
// Acolytes arrive to demand vengeance for Astaroth
function sendAcolyte(uint256 wagdieTokenId, uint256 acolyteTokenId) public {
}
// Once Vengeance has been granted and agreed, Acolytes may return
function returnAcolyte() public {
}
// The Two may slay random Acolytes
function slayAcolyte() public {
}
// The Two grant an opportunity at vengeance
function grantVengeance() public {
}
// Individual Acolyte agrees to vengeance
function agreeVengeance() public {
require(<FILL_ME>)
submissions[msg.sender].vengeanceAgreed = true;
}
// Random number generator
function _getPseudoRandomNumber() private view returns (uint256) {
}
// Locate address index within array (for removals)
function _findAddressIndex(address addr) private view returns (uint256) {
}
// Remove address from array by index (does not affect memory)
function _removeAddressFromSubmitters(uint256 index) private {
}
}
| submissions[msg.sender].wagdieTokenId!=0,"No Acolyte from this address is present." | 450,637 | submissions[msg.sender].wagdieTokenId!=0 |
"Not Reach VIP Sale Time" | 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 PeacefulApeClub is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0 ether;
uint256 public maxMintAmount = 3000;
uint256 public nftPerAddressLimit = 1;
uint256 public currentPhaseMintMaxAmount = 1;
uint256 public maxSupply;
uint32 public publicSaleStart = 1647136800;
uint32 public preSaleStart = 1646964000;
uint32 public vipSaleStart = 1646618400;
bool public publicSalePaused = false;
bool public preSalePaused = false;
bool public vipSalePaused = false;
bool public revealed = false;
bool public onlyWhitelisted = false;
mapping(address => uint256) vipMintAmount;
mapping(address => uint256) whitelistMint;
mapping(address => uint256) addressMintedBalance;
// addresses to manage this contract
mapping(address => bool) controllers;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
uint256 _maxSettingAmountPerMint,
uint256 _maxCollectionSize
) ERC721A(_name, _symbol, _maxSettingAmountPerMint, _maxCollectionSize) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function vipSaleMint(uint256 _mintAmount) public {
require(_mintAmount > 0, "Mint Amount should be bigger than 0");
require(<FILL_ME>)
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= currentPhaseMintMaxAmount, "reach current Phase NFT limit");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != owner()) {
require(vipMintAmount[msg.sender] != 0, "user is not VIP");
uint256 vipMintCount = vipMintAmount[msg.sender];
require(ownerMintedCount + _mintAmount <= vipMintCount, "max VIP Mint Amount exceeded");
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
}
addressMintedBalance[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function preSaleMint(uint256 _mintAmount) public payable {
}
function publicSaleMint(uint256 _mintAmount) public payable {
}
function checkWhitelistMintAmount(address _account) public view returns (uint256) {
}
/**
* This implementation is only for read purpose
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
/**
* token Id start from 0 due to 721A implementation
*
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function publicSaleIsActive() public view returns (bool) {
}
function preSaleIsActive() public view returns (bool) {
}
function vipSaleIsActive() public view returns (bool) {
}
function checkVIPMintAmount(address _account) public view returns (uint256) {
}
// for controller
function reveal(bool _state) public {
}
function setNftPerAddressLimit(uint256 _limit) public {
}
function setCost(uint256 _newCost) public {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public {
}
function setcurrentPhaseMintMaxAmount(uint256 _newPhaseAmount) public {
}
function setPublicSaleStart(uint32 timestamp) public {
}
function setPreSaleStart(uint32 timestamp) public {
}
function setVIPSaleStart(uint32 timestamp) public {
}
function setBaseURI(string memory _newBaseURI) public {
}
function setBaseExtension(string memory _newBaseExtension) public {
}
function setNotRevealedURI(string memory _notRevealedURI) public {
}
function setPreSalePause(bool _state) public {
}
function setVIPSalePause(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function setVIPUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
function setPublicSalePause(bool _state) public {
}
function setOnlyWhitelisted(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function whitelistUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
//only owner
/**
* enables an address for management
* @param controller the address to enable
*/
function addController(address controller) external onlyOwner {
}
/**
* disables an address for management
* @param controller the address to disbale
*/
function removeController(address controller) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| (!vipSalePaused)&&(vipSaleStart<=block.timestamp),"Not Reach VIP Sale Time" | 450,801 | (!vipSalePaused)&&(vipSaleStart<=block.timestamp) |
"reach current Phase NFT limit" | 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 PeacefulApeClub is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0 ether;
uint256 public maxMintAmount = 3000;
uint256 public nftPerAddressLimit = 1;
uint256 public currentPhaseMintMaxAmount = 1;
uint256 public maxSupply;
uint32 public publicSaleStart = 1647136800;
uint32 public preSaleStart = 1646964000;
uint32 public vipSaleStart = 1646618400;
bool public publicSalePaused = false;
bool public preSalePaused = false;
bool public vipSalePaused = false;
bool public revealed = false;
bool public onlyWhitelisted = false;
mapping(address => uint256) vipMintAmount;
mapping(address => uint256) whitelistMint;
mapping(address => uint256) addressMintedBalance;
// addresses to manage this contract
mapping(address => bool) controllers;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
uint256 _maxSettingAmountPerMint,
uint256 _maxCollectionSize
) ERC721A(_name, _symbol, _maxSettingAmountPerMint, _maxCollectionSize) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function vipSaleMint(uint256 _mintAmount) public {
require(_mintAmount > 0, "Mint Amount should be bigger than 0");
require((!vipSalePaused)&&(vipSaleStart <= block.timestamp), "Not Reach VIP Sale Time");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(<FILL_ME>)
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != owner()) {
require(vipMintAmount[msg.sender] != 0, "user is not VIP");
uint256 vipMintCount = vipMintAmount[msg.sender];
require(ownerMintedCount + _mintAmount <= vipMintCount, "max VIP Mint Amount exceeded");
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
}
addressMintedBalance[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function preSaleMint(uint256 _mintAmount) public payable {
}
function publicSaleMint(uint256 _mintAmount) public payable {
}
function checkWhitelistMintAmount(address _account) public view returns (uint256) {
}
/**
* This implementation is only for read purpose
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
/**
* token Id start from 0 due to 721A implementation
*
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function publicSaleIsActive() public view returns (bool) {
}
function preSaleIsActive() public view returns (bool) {
}
function vipSaleIsActive() public view returns (bool) {
}
function checkVIPMintAmount(address _account) public view returns (uint256) {
}
// for controller
function reveal(bool _state) public {
}
function setNftPerAddressLimit(uint256 _limit) public {
}
function setCost(uint256 _newCost) public {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public {
}
function setcurrentPhaseMintMaxAmount(uint256 _newPhaseAmount) public {
}
function setPublicSaleStart(uint32 timestamp) public {
}
function setPreSaleStart(uint32 timestamp) public {
}
function setVIPSaleStart(uint32 timestamp) public {
}
function setBaseURI(string memory _newBaseURI) public {
}
function setBaseExtension(string memory _newBaseExtension) public {
}
function setNotRevealedURI(string memory _notRevealedURI) public {
}
function setPreSalePause(bool _state) public {
}
function setVIPSalePause(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function setVIPUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
function setPublicSalePause(bool _state) public {
}
function setOnlyWhitelisted(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function whitelistUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
//only owner
/**
* enables an address for management
* @param controller the address to enable
*/
function addController(address controller) external onlyOwner {
}
/**
* disables an address for management
* @param controller the address to disbale
*/
function removeController(address controller) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| supply+_mintAmount<=currentPhaseMintMaxAmount,"reach current Phase NFT limit" | 450,801 | supply+_mintAmount<=currentPhaseMintMaxAmount |
"user is not VIP" | 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 PeacefulApeClub is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0 ether;
uint256 public maxMintAmount = 3000;
uint256 public nftPerAddressLimit = 1;
uint256 public currentPhaseMintMaxAmount = 1;
uint256 public maxSupply;
uint32 public publicSaleStart = 1647136800;
uint32 public preSaleStart = 1646964000;
uint32 public vipSaleStart = 1646618400;
bool public publicSalePaused = false;
bool public preSalePaused = false;
bool public vipSalePaused = false;
bool public revealed = false;
bool public onlyWhitelisted = false;
mapping(address => uint256) vipMintAmount;
mapping(address => uint256) whitelistMint;
mapping(address => uint256) addressMintedBalance;
// addresses to manage this contract
mapping(address => bool) controllers;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
uint256 _maxSettingAmountPerMint,
uint256 _maxCollectionSize
) ERC721A(_name, _symbol, _maxSettingAmountPerMint, _maxCollectionSize) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function vipSaleMint(uint256 _mintAmount) public {
require(_mintAmount > 0, "Mint Amount should be bigger than 0");
require((!vipSalePaused)&&(vipSaleStart <= block.timestamp), "Not Reach VIP Sale Time");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= currentPhaseMintMaxAmount, "reach current Phase NFT limit");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != owner()) {
require(<FILL_ME>)
uint256 vipMintCount = vipMintAmount[msg.sender];
require(ownerMintedCount + _mintAmount <= vipMintCount, "max VIP Mint Amount exceeded");
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
}
addressMintedBalance[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function preSaleMint(uint256 _mintAmount) public payable {
}
function publicSaleMint(uint256 _mintAmount) public payable {
}
function checkWhitelistMintAmount(address _account) public view returns (uint256) {
}
/**
* This implementation is only for read purpose
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
/**
* token Id start from 0 due to 721A implementation
*
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function publicSaleIsActive() public view returns (bool) {
}
function preSaleIsActive() public view returns (bool) {
}
function vipSaleIsActive() public view returns (bool) {
}
function checkVIPMintAmount(address _account) public view returns (uint256) {
}
// for controller
function reveal(bool _state) public {
}
function setNftPerAddressLimit(uint256 _limit) public {
}
function setCost(uint256 _newCost) public {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public {
}
function setcurrentPhaseMintMaxAmount(uint256 _newPhaseAmount) public {
}
function setPublicSaleStart(uint32 timestamp) public {
}
function setPreSaleStart(uint32 timestamp) public {
}
function setVIPSaleStart(uint32 timestamp) public {
}
function setBaseURI(string memory _newBaseURI) public {
}
function setBaseExtension(string memory _newBaseExtension) public {
}
function setNotRevealedURI(string memory _notRevealedURI) public {
}
function setPreSalePause(bool _state) public {
}
function setVIPSalePause(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function setVIPUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
function setPublicSalePause(bool _state) public {
}
function setOnlyWhitelisted(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function whitelistUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
//only owner
/**
* enables an address for management
* @param controller the address to enable
*/
function addController(address controller) external onlyOwner {
}
/**
* disables an address for management
* @param controller the address to disbale
*/
function removeController(address controller) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| vipMintAmount[msg.sender]!=0,"user is not VIP" | 450,801 | vipMintAmount[msg.sender]!=0 |
"max VIP Mint Amount 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 PeacefulApeClub is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0 ether;
uint256 public maxMintAmount = 3000;
uint256 public nftPerAddressLimit = 1;
uint256 public currentPhaseMintMaxAmount = 1;
uint256 public maxSupply;
uint32 public publicSaleStart = 1647136800;
uint32 public preSaleStart = 1646964000;
uint32 public vipSaleStart = 1646618400;
bool public publicSalePaused = false;
bool public preSalePaused = false;
bool public vipSalePaused = false;
bool public revealed = false;
bool public onlyWhitelisted = false;
mapping(address => uint256) vipMintAmount;
mapping(address => uint256) whitelistMint;
mapping(address => uint256) addressMintedBalance;
// addresses to manage this contract
mapping(address => bool) controllers;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
uint256 _maxSettingAmountPerMint,
uint256 _maxCollectionSize
) ERC721A(_name, _symbol, _maxSettingAmountPerMint, _maxCollectionSize) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function vipSaleMint(uint256 _mintAmount) public {
require(_mintAmount > 0, "Mint Amount should be bigger than 0");
require((!vipSalePaused)&&(vipSaleStart <= block.timestamp), "Not Reach VIP Sale Time");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= currentPhaseMintMaxAmount, "reach current Phase NFT limit");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if (msg.sender != owner()) {
require(vipMintAmount[msg.sender] != 0, "user is not VIP");
uint256 vipMintCount = vipMintAmount[msg.sender];
require(<FILL_ME>)
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
}
addressMintedBalance[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function preSaleMint(uint256 _mintAmount) public payable {
}
function publicSaleMint(uint256 _mintAmount) public payable {
}
function checkWhitelistMintAmount(address _account) public view returns (uint256) {
}
/**
* This implementation is only for read purpose
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
/**
* token Id start from 0 due to 721A implementation
*
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function publicSaleIsActive() public view returns (bool) {
}
function preSaleIsActive() public view returns (bool) {
}
function vipSaleIsActive() public view returns (bool) {
}
function checkVIPMintAmount(address _account) public view returns (uint256) {
}
// for controller
function reveal(bool _state) public {
}
function setNftPerAddressLimit(uint256 _limit) public {
}
function setCost(uint256 _newCost) public {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public {
}
function setcurrentPhaseMintMaxAmount(uint256 _newPhaseAmount) public {
}
function setPublicSaleStart(uint32 timestamp) public {
}
function setPreSaleStart(uint32 timestamp) public {
}
function setVIPSaleStart(uint32 timestamp) public {
}
function setBaseURI(string memory _newBaseURI) public {
}
function setBaseExtension(string memory _newBaseExtension) public {
}
function setNotRevealedURI(string memory _notRevealedURI) public {
}
function setPreSalePause(bool _state) public {
}
function setVIPSalePause(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function setVIPUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
function setPublicSalePause(bool _state) public {
}
function setOnlyWhitelisted(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function whitelistUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
//only owner
/**
* enables an address for management
* @param controller the address to enable
*/
function addController(address controller) external onlyOwner {
}
/**
* disables an address for management
* @param controller the address to disbale
*/
function removeController(address controller) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| ownerMintedCount+_mintAmount<=vipMintCount,"max VIP Mint Amount exceeded" | 450,801 | ownerMintedCount+_mintAmount<=vipMintCount |
"Not Reach Pre Sale Time" | 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 PeacefulApeClub is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0 ether;
uint256 public maxMintAmount = 3000;
uint256 public nftPerAddressLimit = 1;
uint256 public currentPhaseMintMaxAmount = 1;
uint256 public maxSupply;
uint32 public publicSaleStart = 1647136800;
uint32 public preSaleStart = 1646964000;
uint32 public vipSaleStart = 1646618400;
bool public publicSalePaused = false;
bool public preSalePaused = false;
bool public vipSalePaused = false;
bool public revealed = false;
bool public onlyWhitelisted = false;
mapping(address => uint256) vipMintAmount;
mapping(address => uint256) whitelistMint;
mapping(address => uint256) addressMintedBalance;
// addresses to manage this contract
mapping(address => bool) controllers;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
uint256 _maxSettingAmountPerMint,
uint256 _maxCollectionSize
) ERC721A(_name, _symbol, _maxSettingAmountPerMint, _maxCollectionSize) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function vipSaleMint(uint256 _mintAmount) public {
}
function preSaleMint(uint256 _mintAmount) public payable {
require(_mintAmount > 0, "Mint Amount should be bigger than 0");
require(<FILL_ME>)
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= currentPhaseMintMaxAmount, "reach current Phase NFT limit");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if(onlyWhitelisted == true) {
require(whitelistMint[msg.sender] != 0, "user is not whitelisted");
uint256 whitelistMintCount = whitelistMint[msg.sender];
require(ownerMintedCount + _mintAmount <= whitelistMintCount, "max whitelist Mint Amount exceeded");
}
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
require(msg.value >= cost * _mintAmount, "insufficient funds");
addressMintedBalance[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function publicSaleMint(uint256 _mintAmount) public payable {
}
function checkWhitelistMintAmount(address _account) public view returns (uint256) {
}
/**
* This implementation is only for read purpose
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
/**
* token Id start from 0 due to 721A implementation
*
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function publicSaleIsActive() public view returns (bool) {
}
function preSaleIsActive() public view returns (bool) {
}
function vipSaleIsActive() public view returns (bool) {
}
function checkVIPMintAmount(address _account) public view returns (uint256) {
}
// for controller
function reveal(bool _state) public {
}
function setNftPerAddressLimit(uint256 _limit) public {
}
function setCost(uint256 _newCost) public {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public {
}
function setcurrentPhaseMintMaxAmount(uint256 _newPhaseAmount) public {
}
function setPublicSaleStart(uint32 timestamp) public {
}
function setPreSaleStart(uint32 timestamp) public {
}
function setVIPSaleStart(uint32 timestamp) public {
}
function setBaseURI(string memory _newBaseURI) public {
}
function setBaseExtension(string memory _newBaseExtension) public {
}
function setNotRevealedURI(string memory _notRevealedURI) public {
}
function setPreSalePause(bool _state) public {
}
function setVIPSalePause(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function setVIPUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
function setPublicSalePause(bool _state) public {
}
function setOnlyWhitelisted(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function whitelistUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
//only owner
/**
* enables an address for management
* @param controller the address to enable
*/
function addController(address controller) external onlyOwner {
}
/**
* disables an address for management
* @param controller the address to disbale
*/
function removeController(address controller) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| (!preSalePaused)&&(preSaleStart<=block.timestamp),"Not Reach Pre Sale Time" | 450,801 | (!preSalePaused)&&(preSaleStart<=block.timestamp) |
"user is not whitelisted" | 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 PeacefulApeClub is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0 ether;
uint256 public maxMintAmount = 3000;
uint256 public nftPerAddressLimit = 1;
uint256 public currentPhaseMintMaxAmount = 1;
uint256 public maxSupply;
uint32 public publicSaleStart = 1647136800;
uint32 public preSaleStart = 1646964000;
uint32 public vipSaleStart = 1646618400;
bool public publicSalePaused = false;
bool public preSalePaused = false;
bool public vipSalePaused = false;
bool public revealed = false;
bool public onlyWhitelisted = false;
mapping(address => uint256) vipMintAmount;
mapping(address => uint256) whitelistMint;
mapping(address => uint256) addressMintedBalance;
// addresses to manage this contract
mapping(address => bool) controllers;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
uint256 _maxSettingAmountPerMint,
uint256 _maxCollectionSize
) ERC721A(_name, _symbol, _maxSettingAmountPerMint, _maxCollectionSize) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function vipSaleMint(uint256 _mintAmount) public {
}
function preSaleMint(uint256 _mintAmount) public payable {
require(_mintAmount > 0, "Mint Amount should be bigger than 0");
require((!preSalePaused)&&(preSaleStart <= block.timestamp), "Not Reach Pre Sale Time");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= currentPhaseMintMaxAmount, "reach current Phase NFT limit");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if(onlyWhitelisted == true) {
require(<FILL_ME>)
uint256 whitelistMintCount = whitelistMint[msg.sender];
require(ownerMintedCount + _mintAmount <= whitelistMintCount, "max whitelist Mint Amount exceeded");
}
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
require(msg.value >= cost * _mintAmount, "insufficient funds");
addressMintedBalance[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function publicSaleMint(uint256 _mintAmount) public payable {
}
function checkWhitelistMintAmount(address _account) public view returns (uint256) {
}
/**
* This implementation is only for read purpose
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
/**
* token Id start from 0 due to 721A implementation
*
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function publicSaleIsActive() public view returns (bool) {
}
function preSaleIsActive() public view returns (bool) {
}
function vipSaleIsActive() public view returns (bool) {
}
function checkVIPMintAmount(address _account) public view returns (uint256) {
}
// for controller
function reveal(bool _state) public {
}
function setNftPerAddressLimit(uint256 _limit) public {
}
function setCost(uint256 _newCost) public {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public {
}
function setcurrentPhaseMintMaxAmount(uint256 _newPhaseAmount) public {
}
function setPublicSaleStart(uint32 timestamp) public {
}
function setPreSaleStart(uint32 timestamp) public {
}
function setVIPSaleStart(uint32 timestamp) public {
}
function setBaseURI(string memory _newBaseURI) public {
}
function setBaseExtension(string memory _newBaseExtension) public {
}
function setNotRevealedURI(string memory _notRevealedURI) public {
}
function setPreSalePause(bool _state) public {
}
function setVIPSalePause(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function setVIPUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
function setPublicSalePause(bool _state) public {
}
function setOnlyWhitelisted(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function whitelistUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
//only owner
/**
* enables an address for management
* @param controller the address to enable
*/
function addController(address controller) external onlyOwner {
}
/**
* disables an address for management
* @param controller the address to disbale
*/
function removeController(address controller) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| whitelistMint[msg.sender]!=0,"user is not whitelisted" | 450,801 | whitelistMint[msg.sender]!=0 |
"max whitelist Mint Amount 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 PeacefulApeClub is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0 ether;
uint256 public maxMintAmount = 3000;
uint256 public nftPerAddressLimit = 1;
uint256 public currentPhaseMintMaxAmount = 1;
uint256 public maxSupply;
uint32 public publicSaleStart = 1647136800;
uint32 public preSaleStart = 1646964000;
uint32 public vipSaleStart = 1646618400;
bool public publicSalePaused = false;
bool public preSalePaused = false;
bool public vipSalePaused = false;
bool public revealed = false;
bool public onlyWhitelisted = false;
mapping(address => uint256) vipMintAmount;
mapping(address => uint256) whitelistMint;
mapping(address => uint256) addressMintedBalance;
// addresses to manage this contract
mapping(address => bool) controllers;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
uint256 _maxSettingAmountPerMint,
uint256 _maxCollectionSize
) ERC721A(_name, _symbol, _maxSettingAmountPerMint, _maxCollectionSize) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function vipSaleMint(uint256 _mintAmount) public {
}
function preSaleMint(uint256 _mintAmount) public payable {
require(_mintAmount > 0, "Mint Amount should be bigger than 0");
require((!preSalePaused)&&(preSaleStart <= block.timestamp), "Not Reach Pre Sale Time");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= currentPhaseMintMaxAmount, "reach current Phase NFT limit");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if(onlyWhitelisted == true) {
require(whitelistMint[msg.sender] != 0, "user is not whitelisted");
uint256 whitelistMintCount = whitelistMint[msg.sender];
require(<FILL_ME>)
}
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
require(msg.value >= cost * _mintAmount, "insufficient funds");
addressMintedBalance[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function publicSaleMint(uint256 _mintAmount) public payable {
}
function checkWhitelistMintAmount(address _account) public view returns (uint256) {
}
/**
* This implementation is only for read purpose
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
/**
* token Id start from 0 due to 721A implementation
*
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function publicSaleIsActive() public view returns (bool) {
}
function preSaleIsActive() public view returns (bool) {
}
function vipSaleIsActive() public view returns (bool) {
}
function checkVIPMintAmount(address _account) public view returns (uint256) {
}
// for controller
function reveal(bool _state) public {
}
function setNftPerAddressLimit(uint256 _limit) public {
}
function setCost(uint256 _newCost) public {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public {
}
function setcurrentPhaseMintMaxAmount(uint256 _newPhaseAmount) public {
}
function setPublicSaleStart(uint32 timestamp) public {
}
function setPreSaleStart(uint32 timestamp) public {
}
function setVIPSaleStart(uint32 timestamp) public {
}
function setBaseURI(string memory _newBaseURI) public {
}
function setBaseExtension(string memory _newBaseExtension) public {
}
function setNotRevealedURI(string memory _notRevealedURI) public {
}
function setPreSalePause(bool _state) public {
}
function setVIPSalePause(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function setVIPUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
function setPublicSalePause(bool _state) public {
}
function setOnlyWhitelisted(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function whitelistUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
//only owner
/**
* enables an address for management
* @param controller the address to enable
*/
function addController(address controller) external onlyOwner {
}
/**
* disables an address for management
* @param controller the address to disbale
*/
function removeController(address controller) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| ownerMintedCount+_mintAmount<=whitelistMintCount,"max whitelist Mint Amount exceeded" | 450,801 | ownerMintedCount+_mintAmount<=whitelistMintCount |
"Not Reach Public Sale Time" | 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 PeacefulApeClub is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0 ether;
uint256 public maxMintAmount = 3000;
uint256 public nftPerAddressLimit = 1;
uint256 public currentPhaseMintMaxAmount = 1;
uint256 public maxSupply;
uint32 public publicSaleStart = 1647136800;
uint32 public preSaleStart = 1646964000;
uint32 public vipSaleStart = 1646618400;
bool public publicSalePaused = false;
bool public preSalePaused = false;
bool public vipSalePaused = false;
bool public revealed = false;
bool public onlyWhitelisted = false;
mapping(address => uint256) vipMintAmount;
mapping(address => uint256) whitelistMint;
mapping(address => uint256) addressMintedBalance;
// addresses to manage this contract
mapping(address => bool) controllers;
constructor(
string memory _name,
string memory _symbol,
string memory _initBaseURI,
string memory _initNotRevealedUri,
uint256 _maxSettingAmountPerMint,
uint256 _maxCollectionSize
) ERC721A(_name, _symbol, _maxSettingAmountPerMint, _maxCollectionSize) {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
// public
function vipSaleMint(uint256 _mintAmount) public {
}
function preSaleMint(uint256 _mintAmount) public payable {
}
function publicSaleMint(uint256 _mintAmount) public payable {
require(_mintAmount > 0, "Mint Amount should be bigger than 0");
require(<FILL_ME>)
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= currentPhaseMintMaxAmount, "reach current Phase NFT limit");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
if(onlyWhitelisted == true) {
require(whitelistMint[msg.sender] != 0, "user is not whitelisted");
uint256 whitelistMintCount = whitelistMint[msg.sender];
require(ownerMintedCount + _mintAmount <= whitelistMintCount, "max whitelist Mint Amount exceeded");
}
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
require(msg.value >= cost * _mintAmount, "insufficient funds");
addressMintedBalance[msg.sender] += _mintAmount;
_safeMint(msg.sender, _mintAmount);
}
function checkWhitelistMintAmount(address _account) public view returns (uint256) {
}
/**
* This implementation is only for read purpose
*/
function walletOfOwner(address _owner) public view returns (uint256[] memory)
{
}
/**
* token Id start from 0 due to 721A implementation
*
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
{
}
function publicSaleIsActive() public view returns (bool) {
}
function preSaleIsActive() public view returns (bool) {
}
function vipSaleIsActive() public view returns (bool) {
}
function checkVIPMintAmount(address _account) public view returns (uint256) {
}
// for controller
function reveal(bool _state) public {
}
function setNftPerAddressLimit(uint256 _limit) public {
}
function setCost(uint256 _newCost) public {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public {
}
function setcurrentPhaseMintMaxAmount(uint256 _newPhaseAmount) public {
}
function setPublicSaleStart(uint32 timestamp) public {
}
function setPreSaleStart(uint32 timestamp) public {
}
function setVIPSaleStart(uint32 timestamp) public {
}
function setBaseURI(string memory _newBaseURI) public {
}
function setBaseExtension(string memory _newBaseExtension) public {
}
function setNotRevealedURI(string memory _notRevealedURI) public {
}
function setPreSalePause(bool _state) public {
}
function setVIPSalePause(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function setVIPUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
function setPublicSalePause(bool _state) public {
}
function setOnlyWhitelisted(bool _state) public {
}
/**
* This implementation is only for less than 1000 lists in WL with 100 lists a batch in Ethereum
* cost 35000 gaslimit a list after the initial 50000 gaslimit
*/
function whitelistUsers(address[] memory _accounts, uint256[] memory _amounts) public {
}
//only owner
/**
* enables an address for management
* @param controller the address to enable
*/
function addController(address controller) external onlyOwner {
}
/**
* disables an address for management
* @param controller the address to disbale
*/
function removeController(address controller) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| (!publicSalePaused)&&(publicSaleStart<=block.timestamp),"Not Reach Public Sale Time" | 450,801 | (!publicSalePaused)&&(publicSaleStart<=block.timestamp) |
"ALL 250 LOST ASTRONAUTS HAVE BEEN RECOVERED" | // SPDX-License-Identifier: MIT
/*///////////////////////////////////////////////////////////////////////////////////
LOST ASTRONAUTS BY KEN KELLEHER
*////////////////////////////////////////////////////////////////////////////////////
// ABASHO COLLECTIVE DROP
//-----------------------
// ART BY: ANCHORBALL / KEN KELLEHER
// AUTHOR: NODESTARQ
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "erc721a/contracts/ERC721A.sol";
contract LostAstronauts is ERC721A, Ownable {
// REGULAR MINT VARIABLES //
bool public riftOpen; //MINT START BOOL
uint256 public constant ASTRONAUTS = 250; //MAX SUPPLY
uint256 public constant WALLETLIMIT = 5; //WALLET LIMIT
uint256 public constant REGULAR_COST = 0.04 ether; //MINT PRICE FOR REGULAR MINTER
uint256 randOffset; //RANDOM OFFSET VALUE
string private baseURI; //TOKENURI
mapping(address => uint) public addressClaimed; //KEEP TRACK OF CLAIMED LOST ASTRONAUTS
// ABASHO COLLECTIVE MINT//
bool public riftOpenAbasho; //ABASHO MINT START BOOL
address public AbashoContract = 0xE9C79B33C3A06f5Ae7369599F5a1e2FF886e17F0; //ABASHO SMART CONTRACT ADDRESS
uint256 public constant ABASHO_COST = 0.01 ether; //MINT PRICE FOR ABASHO HOLDER
mapping(uint256=>bool) public abashoClaimed; //ABASHO CLAIMED CHECKER
//CREATE NFT COLLECTION
constructor() ERC721A("The Lost Astronauts", "LOST"){} //TOKEN NAME
//START AT TOKEN 1 INSTEAD OF 0
function _startTokenId() internal view virtual override returns (uint256) {
}
//STARTS REGULAR MINT
function openRift() external onlyOwner {
}
//STARTS ABASHO MINT
function openRiftAbasho() external onlyOwner {
}
//ABASHO MINT FUNCTION
function abashoRecoverAstronaut(uint256 _abashoId) external payable {
IERC721 abasho = IERC721(AbashoContract); //ABASHO INTERFACE
uint256 total = totalSupply();
require(riftOpenAbasho, "NO ABASHO SHORTCUT FOUND"); //CHECK IF ABASHO SALE STARTED
require(<FILL_ME>) //CHECK IF MINTED OUT
require(ABASHO_COST <= msg.value, "NOT ENOUGH ETH"); //CHECK IF ENOUGH ETH PAID
//ABASHO CHECKS START HERE
require(abasho.ownerOf(_abashoId) == _msgSender(), "NOBASHO DETECTED"); //CHECK IF ABASHO OWNER
require(!abashoClaimed[_abashoId], "ABASHO ID HAS ALREADY CLAIMED"); //CHECK IF ABASHO HAS CLAIMED ALREADY
abashoClaimed[_abashoId] = true; //SET CLAIMED VAR
addressClaimed[_msgSender()] += 1; // ADD TO WALLET LIMIT COUNTER
_safeMint(msg.sender, 1); // PULL LOST ASTRONAUT OUT OF THE MERGE EVENT HORIZON
}
//REGULAR MINT FUNCTION
function recoverAstronaut() external payable {
}
//PSEUDO RANDOMIZER: ONLY OWNER CAN CALL
function pseudoRandom() external onlyOwner{
}
//SET TOKENURI LINK: ONLY OWNER CAN CALL
function setSignal(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
//WITHDRAW FUNDS FROM SMART CONTRACT: ONLY OWNER CAN CALL
function withdraw() external onlyOwner{
}
}
| total+1<=ASTRONAUTS,"ALL 250 LOST ASTRONAUTS HAVE BEEN RECOVERED" | 450,805 | total+1<=ASTRONAUTS |
"NOBASHO DETECTED" | // SPDX-License-Identifier: MIT
/*///////////////////////////////////////////////////////////////////////////////////
LOST ASTRONAUTS BY KEN KELLEHER
*////////////////////////////////////////////////////////////////////////////////////
// ABASHO COLLECTIVE DROP
//-----------------------
// ART BY: ANCHORBALL / KEN KELLEHER
// AUTHOR: NODESTARQ
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "erc721a/contracts/ERC721A.sol";
contract LostAstronauts is ERC721A, Ownable {
// REGULAR MINT VARIABLES //
bool public riftOpen; //MINT START BOOL
uint256 public constant ASTRONAUTS = 250; //MAX SUPPLY
uint256 public constant WALLETLIMIT = 5; //WALLET LIMIT
uint256 public constant REGULAR_COST = 0.04 ether; //MINT PRICE FOR REGULAR MINTER
uint256 randOffset; //RANDOM OFFSET VALUE
string private baseURI; //TOKENURI
mapping(address => uint) public addressClaimed; //KEEP TRACK OF CLAIMED LOST ASTRONAUTS
// ABASHO COLLECTIVE MINT//
bool public riftOpenAbasho; //ABASHO MINT START BOOL
address public AbashoContract = 0xE9C79B33C3A06f5Ae7369599F5a1e2FF886e17F0; //ABASHO SMART CONTRACT ADDRESS
uint256 public constant ABASHO_COST = 0.01 ether; //MINT PRICE FOR ABASHO HOLDER
mapping(uint256=>bool) public abashoClaimed; //ABASHO CLAIMED CHECKER
//CREATE NFT COLLECTION
constructor() ERC721A("The Lost Astronauts", "LOST"){} //TOKEN NAME
//START AT TOKEN 1 INSTEAD OF 0
function _startTokenId() internal view virtual override returns (uint256) {
}
//STARTS REGULAR MINT
function openRift() external onlyOwner {
}
//STARTS ABASHO MINT
function openRiftAbasho() external onlyOwner {
}
//ABASHO MINT FUNCTION
function abashoRecoverAstronaut(uint256 _abashoId) external payable {
IERC721 abasho = IERC721(AbashoContract); //ABASHO INTERFACE
uint256 total = totalSupply();
require(riftOpenAbasho, "NO ABASHO SHORTCUT FOUND"); //CHECK IF ABASHO SALE STARTED
require(total + 1 <= ASTRONAUTS, "ALL 250 LOST ASTRONAUTS HAVE BEEN RECOVERED"); //CHECK IF MINTED OUT
require(ABASHO_COST <= msg.value, "NOT ENOUGH ETH"); //CHECK IF ENOUGH ETH PAID
//ABASHO CHECKS START HERE
require(<FILL_ME>) //CHECK IF ABASHO OWNER
require(!abashoClaimed[_abashoId], "ABASHO ID HAS ALREADY CLAIMED"); //CHECK IF ABASHO HAS CLAIMED ALREADY
abashoClaimed[_abashoId] = true; //SET CLAIMED VAR
addressClaimed[_msgSender()] += 1; // ADD TO WALLET LIMIT COUNTER
_safeMint(msg.sender, 1); // PULL LOST ASTRONAUT OUT OF THE MERGE EVENT HORIZON
}
//REGULAR MINT FUNCTION
function recoverAstronaut() external payable {
}
//PSEUDO RANDOMIZER: ONLY OWNER CAN CALL
function pseudoRandom() external onlyOwner{
}
//SET TOKENURI LINK: ONLY OWNER CAN CALL
function setSignal(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
//WITHDRAW FUNDS FROM SMART CONTRACT: ONLY OWNER CAN CALL
function withdraw() external onlyOwner{
}
}
| abasho.ownerOf(_abashoId)==_msgSender(),"NOBASHO DETECTED" | 450,805 | abasho.ownerOf(_abashoId)==_msgSender() |
"ABASHO ID HAS ALREADY CLAIMED" | // SPDX-License-Identifier: MIT
/*///////////////////////////////////////////////////////////////////////////////////
LOST ASTRONAUTS BY KEN KELLEHER
*////////////////////////////////////////////////////////////////////////////////////
// ABASHO COLLECTIVE DROP
//-----------------------
// ART BY: ANCHORBALL / KEN KELLEHER
// AUTHOR: NODESTARQ
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "erc721a/contracts/ERC721A.sol";
contract LostAstronauts is ERC721A, Ownable {
// REGULAR MINT VARIABLES //
bool public riftOpen; //MINT START BOOL
uint256 public constant ASTRONAUTS = 250; //MAX SUPPLY
uint256 public constant WALLETLIMIT = 5; //WALLET LIMIT
uint256 public constant REGULAR_COST = 0.04 ether; //MINT PRICE FOR REGULAR MINTER
uint256 randOffset; //RANDOM OFFSET VALUE
string private baseURI; //TOKENURI
mapping(address => uint) public addressClaimed; //KEEP TRACK OF CLAIMED LOST ASTRONAUTS
// ABASHO COLLECTIVE MINT//
bool public riftOpenAbasho; //ABASHO MINT START BOOL
address public AbashoContract = 0xE9C79B33C3A06f5Ae7369599F5a1e2FF886e17F0; //ABASHO SMART CONTRACT ADDRESS
uint256 public constant ABASHO_COST = 0.01 ether; //MINT PRICE FOR ABASHO HOLDER
mapping(uint256=>bool) public abashoClaimed; //ABASHO CLAIMED CHECKER
//CREATE NFT COLLECTION
constructor() ERC721A("The Lost Astronauts", "LOST"){} //TOKEN NAME
//START AT TOKEN 1 INSTEAD OF 0
function _startTokenId() internal view virtual override returns (uint256) {
}
//STARTS REGULAR MINT
function openRift() external onlyOwner {
}
//STARTS ABASHO MINT
function openRiftAbasho() external onlyOwner {
}
//ABASHO MINT FUNCTION
function abashoRecoverAstronaut(uint256 _abashoId) external payable {
IERC721 abasho = IERC721(AbashoContract); //ABASHO INTERFACE
uint256 total = totalSupply();
require(riftOpenAbasho, "NO ABASHO SHORTCUT FOUND"); //CHECK IF ABASHO SALE STARTED
require(total + 1 <= ASTRONAUTS, "ALL 250 LOST ASTRONAUTS HAVE BEEN RECOVERED"); //CHECK IF MINTED OUT
require(ABASHO_COST <= msg.value, "NOT ENOUGH ETH"); //CHECK IF ENOUGH ETH PAID
//ABASHO CHECKS START HERE
require(abasho.ownerOf(_abashoId) == _msgSender(), "NOBASHO DETECTED"); //CHECK IF ABASHO OWNER
require(<FILL_ME>) //CHECK IF ABASHO HAS CLAIMED ALREADY
abashoClaimed[_abashoId] = true; //SET CLAIMED VAR
addressClaimed[_msgSender()] += 1; // ADD TO WALLET LIMIT COUNTER
_safeMint(msg.sender, 1); // PULL LOST ASTRONAUT OUT OF THE MERGE EVENT HORIZON
}
//REGULAR MINT FUNCTION
function recoverAstronaut() external payable {
}
//PSEUDO RANDOMIZER: ONLY OWNER CAN CALL
function pseudoRandom() external onlyOwner{
}
//SET TOKENURI LINK: ONLY OWNER CAN CALL
function setSignal(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
//WITHDRAW FUNDS FROM SMART CONTRACT: ONLY OWNER CAN CALL
function withdraw() external onlyOwner{
}
}
| !abashoClaimed[_abashoId],"ABASHO ID HAS ALREADY CLAIMED" | 450,805 | !abashoClaimed[_abashoId] |
"YOU CAN'T RECOVER MORE" | // SPDX-License-Identifier: MIT
/*///////////////////////////////////////////////////////////////////////////////////
LOST ASTRONAUTS BY KEN KELLEHER
*////////////////////////////////////////////////////////////////////////////////////
// ABASHO COLLECTIVE DROP
//-----------------------
// ART BY: ANCHORBALL / KEN KELLEHER
// AUTHOR: NODESTARQ
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "erc721a/contracts/ERC721A.sol";
contract LostAstronauts is ERC721A, Ownable {
// REGULAR MINT VARIABLES //
bool public riftOpen; //MINT START BOOL
uint256 public constant ASTRONAUTS = 250; //MAX SUPPLY
uint256 public constant WALLETLIMIT = 5; //WALLET LIMIT
uint256 public constant REGULAR_COST = 0.04 ether; //MINT PRICE FOR REGULAR MINTER
uint256 randOffset; //RANDOM OFFSET VALUE
string private baseURI; //TOKENURI
mapping(address => uint) public addressClaimed; //KEEP TRACK OF CLAIMED LOST ASTRONAUTS
// ABASHO COLLECTIVE MINT//
bool public riftOpenAbasho; //ABASHO MINT START BOOL
address public AbashoContract = 0xE9C79B33C3A06f5Ae7369599F5a1e2FF886e17F0; //ABASHO SMART CONTRACT ADDRESS
uint256 public constant ABASHO_COST = 0.01 ether; //MINT PRICE FOR ABASHO HOLDER
mapping(uint256=>bool) public abashoClaimed; //ABASHO CLAIMED CHECKER
//CREATE NFT COLLECTION
constructor() ERC721A("The Lost Astronauts", "LOST"){} //TOKEN NAME
//START AT TOKEN 1 INSTEAD OF 0
function _startTokenId() internal view virtual override returns (uint256) {
}
//STARTS REGULAR MINT
function openRift() external onlyOwner {
}
//STARTS ABASHO MINT
function openRiftAbasho() external onlyOwner {
}
//ABASHO MINT FUNCTION
function abashoRecoverAstronaut(uint256 _abashoId) external payable {
}
//REGULAR MINT FUNCTION
function recoverAstronaut() external payable {
uint256 total = totalSupply();
require(riftOpen, "MERGE RIFT NOT EMITTING"); //CHECK MINT STARTED
require(total + 1 <= ASTRONAUTS, "ALL 250 LOST ASTRONAUTS HAVE BEEN RECOVERED"); //CHECK IF MINTED OUT
require(<FILL_ME>)
require(REGULAR_COST <= msg.value, "NOT ENOUGH ETH"); //CHECK IF ENOUGH ETH PAID
addressClaimed[_msgSender()] += 1; // ADD TO WALLET LIMIT COUNTER
_safeMint(msg.sender, 1); // PULL LOST ASTRONAUT OUT OF THE MERGE EVENT HORIZON
}
//PSEUDO RANDOMIZER: ONLY OWNER CAN CALL
function pseudoRandom() external onlyOwner{
}
//SET TOKENURI LINK: ONLY OWNER CAN CALL
function setSignal(string memory baseURI_) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
//WITHDRAW FUNDS FROM SMART CONTRACT: ONLY OWNER CAN CALL
function withdraw() external onlyOwner{
}
}
| addressClaimed[_msgSender()]+1<=WALLETLIMIT,"YOU CAN'T RECOVER MORE" | 450,805 | addressClaimed[_msgSender()]+1<=WALLETLIMIT |
"ERC20: Trades already Live!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract ERC20Ownable 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 {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IUniswapV2Router01 {
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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function 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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 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;
}
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 POMPIINU is Context, IERC20, ERC20Ownable {
using SafeMath for uint256;
using Address for address;
string private constant tokenName = "POMPIINU";
string private constant tokenSymbol = "POMPI";
uint8 private constant tokenDecimal = 9;
uint256 private constant tokenSupply = 1e6 * 10**tokenDecimal;
mapping(address => mapping(address => uint256)) private tokenAllowances;
mapping(address => uint256) private tokenBalance;
mapping(address => bool) private isMaxWalletExcluded;
mapping(address => bool) private isLiveExcluded;
mapping(address => bool) public isBot;
address payable liquidityAddress;
address public uniV2Pair;
IUniswapV2Router02 public uniV2Router;
uint256 private maxWallet;
uint256 public activeTradingBlock;
bool public maxWalletOn = false;
bool public live = false;
constructor() payable {
}
receive() external payable {}
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function internalApprove(address owner,address spender,uint256 amount) internal {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender,address recipient,uint256 amount) external override returns (bool) {
}
function GoLive() external onlyOwner returns (bool){
require(<FILL_ME>)
activeTradingBlock = block.number;
IUniswapV2Router02 _uniV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniV2Router = _uniV2Router;
isMaxWalletExcluded[address(uniV2Router)] = true;
internalApprove(address(this), address(uniV2Router), tokenSupply);
uniV2Pair = IUniswapV2Factory(_uniV2Router.factory()).createPair(address(this), _uniV2Router.WETH());
isMaxWalletExcluded[address(uniV2Pair)] = true;
require(address(this).balance > 0, "ERC20: Must have ETH on contract to Go Live!");
addLiquidity(balanceOf(address(this)), address(this).balance);
maxWalletOn = true;
live = true;
return true;
}
function internalTransfer(address from, address to, uint256 amount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function tokenTransfer(address sender,address recipient,uint256 amount) internal {
}
function withdrawStuckETH() external onlyOwner {
}
function addBot(address account) external onlyOwner {
}
function removeBot(address account) external onlyOwner {
}
function setMaxWalletAmount(uint256 percent, uint256 divider) external onlyOwner {
}
function setStatusMaxWallet(bool trueORfalse) external onlyOwner {
}
}
| !live,"ERC20: Trades already Live!" | 450,842 | !live |
"ERC20: Trading Is Not Live!" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract ERC20Ownable 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 {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IUniswapV2Router01 {
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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function 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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 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;
}
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 POMPIINU is Context, IERC20, ERC20Ownable {
using SafeMath for uint256;
using Address for address;
string private constant tokenName = "POMPIINU";
string private constant tokenSymbol = "POMPI";
uint8 private constant tokenDecimal = 9;
uint256 private constant tokenSupply = 1e6 * 10**tokenDecimal;
mapping(address => mapping(address => uint256)) private tokenAllowances;
mapping(address => uint256) private tokenBalance;
mapping(address => bool) private isMaxWalletExcluded;
mapping(address => bool) private isLiveExcluded;
mapping(address => bool) public isBot;
address payable liquidityAddress;
address public uniV2Pair;
IUniswapV2Router02 public uniV2Router;
uint256 private maxWallet;
uint256 public activeTradingBlock;
bool public maxWalletOn = false;
bool public live = false;
constructor() payable {
}
receive() external payable {}
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function internalApprove(address owner,address spender,uint256 amount) internal {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender,address recipient,uint256 amount) external override returns (bool) {
}
function GoLive() external onlyOwner returns (bool){
}
function internalTransfer(address from, address to, uint256 amount) internal {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: Transfer amount must be greater than zero");
require(!isBot[from], "ERC20: Can not transfer from BOT");
if(!live){
require(<FILL_ME>)
}
if (maxWalletOn == true && !isMaxWalletExcluded[to]) {
require(balanceOf(to).add(amount) <= maxWallet, "ERC20: Max amount of tokens for wallet reached");
}
tokenTransfer(from, to, amount);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function tokenTransfer(address sender,address recipient,uint256 amount) internal {
}
function withdrawStuckETH() external onlyOwner {
}
function addBot(address account) external onlyOwner {
}
function removeBot(address account) external onlyOwner {
}
function setMaxWalletAmount(uint256 percent, uint256 divider) external onlyOwner {
}
function setStatusMaxWallet(bool trueORfalse) external onlyOwner {
}
}
| isLiveExcluded[from]||isLiveExcluded[to],"ERC20: Trading Is Not Live!" | 450,842 | isLiveExcluded[from]||isLiveExcluded[to] |
"ERC20: Max amount of tokens for wallet reached" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract ERC20Ownable 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 {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IUniswapV2Router01 {
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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function 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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 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;
}
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 POMPIINU is Context, IERC20, ERC20Ownable {
using SafeMath for uint256;
using Address for address;
string private constant tokenName = "POMPIINU";
string private constant tokenSymbol = "POMPI";
uint8 private constant tokenDecimal = 9;
uint256 private constant tokenSupply = 1e6 * 10**tokenDecimal;
mapping(address => mapping(address => uint256)) private tokenAllowances;
mapping(address => uint256) private tokenBalance;
mapping(address => bool) private isMaxWalletExcluded;
mapping(address => bool) private isLiveExcluded;
mapping(address => bool) public isBot;
address payable liquidityAddress;
address public uniV2Pair;
IUniswapV2Router02 public uniV2Router;
uint256 private maxWallet;
uint256 public activeTradingBlock;
bool public maxWalletOn = false;
bool public live = false;
constructor() payable {
}
receive() external payable {}
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function internalApprove(address owner,address spender,uint256 amount) internal {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender,address recipient,uint256 amount) external override returns (bool) {
}
function GoLive() external onlyOwner returns (bool){
}
function internalTransfer(address from, address to, uint256 amount) internal {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: Transfer amount must be greater than zero");
require(!isBot[from], "ERC20: Can not transfer from BOT");
if(!live){
require(isLiveExcluded[from] || isLiveExcluded[to], "ERC20: Trading Is Not Live!");
}
if (maxWalletOn == true && !isMaxWalletExcluded[to]) {
require(<FILL_ME>)
}
tokenTransfer(from, to, amount);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function tokenTransfer(address sender,address recipient,uint256 amount) internal {
}
function withdrawStuckETH() external onlyOwner {
}
function addBot(address account) external onlyOwner {
}
function removeBot(address account) external onlyOwner {
}
function setMaxWalletAmount(uint256 percent, uint256 divider) external onlyOwner {
}
function setStatusMaxWallet(bool trueORfalse) external onlyOwner {
}
}
| balanceOf(to).add(amount)<=maxWallet,"ERC20: Max amount of tokens for wallet reached" | 450,842 | balanceOf(to).add(amount)<=maxWallet |
"ERC20: Account already added" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract ERC20Ownable 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 {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IUniswapV2Router01 {
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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function 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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 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;
}
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 POMPIINU is Context, IERC20, ERC20Ownable {
using SafeMath for uint256;
using Address for address;
string private constant tokenName = "POMPIINU";
string private constant tokenSymbol = "POMPI";
uint8 private constant tokenDecimal = 9;
uint256 private constant tokenSupply = 1e6 * 10**tokenDecimal;
mapping(address => mapping(address => uint256)) private tokenAllowances;
mapping(address => uint256) private tokenBalance;
mapping(address => bool) private isMaxWalletExcluded;
mapping(address => bool) private isLiveExcluded;
mapping(address => bool) public isBot;
address payable liquidityAddress;
address public uniV2Pair;
IUniswapV2Router02 public uniV2Router;
uint256 private maxWallet;
uint256 public activeTradingBlock;
bool public maxWalletOn = false;
bool public live = false;
constructor() payable {
}
receive() external payable {}
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function internalApprove(address owner,address spender,uint256 amount) internal {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender,address recipient,uint256 amount) external override returns (bool) {
}
function GoLive() external onlyOwner returns (bool){
}
function internalTransfer(address from, address to, uint256 amount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function tokenTransfer(address sender,address recipient,uint256 amount) internal {
}
function withdrawStuckETH() external onlyOwner {
}
function addBot(address account) external onlyOwner {
require(<FILL_ME>)
isBot[account] = true;
}
function removeBot(address account) external onlyOwner {
}
function setMaxWalletAmount(uint256 percent, uint256 divider) external onlyOwner {
}
function setStatusMaxWallet(bool trueORfalse) external onlyOwner {
}
}
| !isBot[account],"ERC20: Account already added" | 450,842 | !isBot[account] |
"ERC20: Account is not bot" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract ERC20Ownable 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 {
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IUniswapV2Router01 {
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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function 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 removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 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;
}
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 POMPIINU is Context, IERC20, ERC20Ownable {
using SafeMath for uint256;
using Address for address;
string private constant tokenName = "POMPIINU";
string private constant tokenSymbol = "POMPI";
uint8 private constant tokenDecimal = 9;
uint256 private constant tokenSupply = 1e6 * 10**tokenDecimal;
mapping(address => mapping(address => uint256)) private tokenAllowances;
mapping(address => uint256) private tokenBalance;
mapping(address => bool) private isMaxWalletExcluded;
mapping(address => bool) private isLiveExcluded;
mapping(address => bool) public isBot;
address payable liquidityAddress;
address public uniV2Pair;
IUniswapV2Router02 public uniV2Router;
uint256 private maxWallet;
uint256 public activeTradingBlock;
bool public maxWalletOn = false;
bool public live = false;
constructor() payable {
}
receive() external payable {}
function name() external pure override returns (string memory) {
}
function symbol() external pure override returns (string memory) {
}
function decimals() external pure override returns (uint8) {
}
function totalSupply() external pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function internalApprove(address owner,address spender,uint256 amount) internal {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender,address recipient,uint256 amount) external override returns (bool) {
}
function GoLive() external onlyOwner returns (bool){
}
function internalTransfer(address from, address to, uint256 amount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function tokenTransfer(address sender,address recipient,uint256 amount) internal {
}
function withdrawStuckETH() external onlyOwner {
}
function addBot(address account) external onlyOwner {
}
function removeBot(address account) external onlyOwner {
require(<FILL_ME>)
isBot[account] = false;
}
function setMaxWalletAmount(uint256 percent, uint256 divider) external onlyOwner {
}
function setStatusMaxWallet(bool trueORfalse) external onlyOwner {
}
}
| isBot[account],"ERC20: Account is not bot" | 450,842 | isBot[account] |
null | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract JCB is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Jeets, Chads & Buybacks";
string private constant _symbol = "JCB";
uint8 private constant _decimals = 18;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private _tradingStarted;
uint256 private _timeTraded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _fTx1;
uint256 private _fTx2;
address payable private _fTxW;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
bool private limitsRemoved = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function tax() public view returns (uint256) {
}
function maxTransactionAmount() public view returns (uint256) {
}
function maxWalletSize() public view returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external{
require(<FILL_ME>)
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function raiseMaxTxAmount(uint256 percentage) external{
}
function raiseMaxWalletSize(uint256 percentage) external{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function BotListAdd(address[] memory bots_) public onlyOwner {
}
function BotListRemove(address notbot) public onlyOwner {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function feeSwapForETH() external {
}
function feeCollectFromContract() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
}
| _msgSender()==_fTxW | 450,963 | _msgSender()==_fTxW |
"Maximum transaction amount must be greater than before" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract JCB is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Jeets, Chads & Buybacks";
string private constant _symbol = "JCB";
uint8 private constant _decimals = 18;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private _tradingStarted;
uint256 private _timeTraded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _fTx1;
uint256 private _fTx2;
address payable private _fTxW;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
bool private limitsRemoved = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function tax() public view returns (uint256) {
}
function maxTransactionAmount() public view returns (uint256) {
}
function maxWalletSize() public view returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external{
}
function raiseMaxTxAmount(uint256 percentage) external{
require(_msgSender() == _fTxW);
require(percentage>0);
require(<FILL_ME>)
_maxTxAmount = _tTotal.mul(percentage).div(100);
}
function raiseMaxWalletSize(uint256 percentage) external{
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function BotListAdd(address[] memory bots_) public onlyOwner {
}
function BotListRemove(address notbot) public onlyOwner {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function feeSwapForETH() external {
}
function feeCollectFromContract() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
}
| (_tTotal.mul(percentage).div(100))>_maxTxAmount,"Maximum transaction amount must be greater than before" | 450,963 | (_tTotal.mul(percentage).div(100))>_maxTxAmount |
"Maximum wallet size must be larger than before" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract JCB is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Jeets, Chads & Buybacks";
string private constant _symbol = "JCB";
uint8 private constant _decimals = 18;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private _tradingStarted;
uint256 private _timeTraded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _fTx1;
uint256 private _fTx2;
address payable private _fTxW;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
bool private limitsRemoved = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function tax() public view returns (uint256) {
}
function maxTransactionAmount() public view returns (uint256) {
}
function maxWalletSize() public view returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external{
}
function raiseMaxTxAmount(uint256 percentage) external{
}
function raiseMaxWalletSize(uint256 percentage) external{
require(_msgSender() == _fTxW);
require(percentage>0);
require(<FILL_ME>)
_maxWalletSize = _tTotal.mul(percentage).div(100);
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function BotListAdd(address[] memory bots_) public onlyOwner {
}
function BotListRemove(address notbot) public onlyOwner {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function feeSwapForETH() external {
}
function feeCollectFromContract() external {
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
}
| (_tTotal.mul(percentage).div(100))>_maxWalletSize,"Maximum wallet size must be larger than before" | 450,963 | (_tTotal.mul(percentage).div(100))>_maxWalletSize |
"Must be authorized to lower fees" | /*
Website: https://thetipcoin.io
Twitter: https://twitter.com/tipcoineth
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "hardhat/console.sol";
library SafeMath {
function tryAdd(uint a, uint b) internal pure returns (bool, uint) {
}
function trySub(uint a, uint b) internal pure returns (bool, uint) {
}
function tryMul(uint a, uint b) internal pure returns (bool, uint) {
}
function tryDiv(uint a, uint b) internal pure returns (bool, uint) {
}
function tryMod(uint a, uint b) internal pure returns (bool, uint) {
}
function add(uint a, uint b) internal pure returns (uint) {
}
function sub(uint a, uint b) internal pure returns (uint) {
}
function mul(uint a, uint b) internal pure returns (uint) {
}
function div(uint a, uint b) internal pure returns (uint) {
}
function mod(uint a, uint b) internal pure returns (uint) {
}
function sub(
uint a,
uint b,
string memory errorMessage
) internal pure returns (uint) {
}
function div(
uint a,
uint b,
string memory errorMessage
) internal pure returns (uint) {
}
function mod(
uint a,
uint b,
string memory errorMessage
) internal pure returns (uint) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (
uint amountToken,
uint amountETH,
uint liquidity
);
}
contract Tip is ERC20, Ownable {
using SafeMath for uint;
IUniswapV2Router02 public immutable uniswapV2Router;
address public constant DeadAddress = address(0xdead);
address public PairAddress;
address public taxWallet;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public marketMakerPairs;
mapping(address => bool) public authorizedEditors;
mapping(uint => uint) private swapInBlock;
uint public maxTransactionAmount;
uint public swapTokensThreshold;
uint public maxWallet;
uint private buyFees;
uint private sellFees;
uint public tradingEnabledInBlock;
uint private delayBlocks = 10;
bool public limitsActive = true;
bool public tradingEnabled = false;
bool public swapEnabled = false;
bool private swapping = false;
constructor(address _taxWallet) ERC20("Tip", "TIP") {
}
function enableTrading() external onlyOwner {
}
function excludeFromFees(address _address, bool _isExcluded) public onlyOwner {
}
function setAuthorizedEditor(address _address, bool _isAuthorized) public onlyOwner {
}
function excludeFromMaxTransaction(address _address, bool _isExcluded) public onlyOwner {
}
function setMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setMarketMakerPair(address pair, bool value) private {
}
function removeLimits() external onlyOwner {
}
function send() external onlyOwner {
}
function _transfer(
address from,
address to,
uint amount
) internal override {
}
function swapTokensForEth(uint tokenAmount) private {
}
function swapBack() private {
}
function lowerTaxes(uint _newBuyFee, uint _newSellFee) external {
require(<FILL_ME>)
require(_newBuyFee <= buyFees, "New fees must be lower than the current");
require(_newSellFee <= sellFees, "New fees must be lower than the current");
buyFees = _newBuyFee;
sellFees = _newSellFee;
}
function lowerSwapThreshold(uint _newValue) external onlyOwner {
}
function addLiquidity() external payable onlyOwner {
}
receive() external payable {}
}
| authorizedEditors[msg.sender],"Must be authorized to lower fees" | 451,101 | authorizedEditors[msg.sender] |
"Max mint per wallet exceeded!" | // Amended by Twenty Four
/**
!Disclaimer!
This contracts have been used to create tutorials,
and was created for the purpose to teach people
how to create smart contracts on the blockchain.
please review this code on your own before using any of
the following code for production.
Twenty Four will not be liable in any way if for the use
of the code. That being said, the code has been tested
to the best of the developers' knowledge to work as intended.
*/
pragma solidity >=0.7.0 <0.9.0;
contract xCBTM is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.00 ether;
uint256 public maxSupply = 99;
uint256 public maxMintAmountPerTx = 1;
uint256 public maxMintAmountPerWallet = 1;
bool public paused = true;
bool public revealed = true;
constructor() ERC721("xCBTM", "xCBTM") { }
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(supply.current() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(<FILL_ME>)
_;
}
// Helper function to get all contract state variables at once
function contractState() public view returns (
bool isPaused,
bool isRevealed,
uint256 maxSupplySet,
uint256 maxMintAmountPerTxSet,
uint256 maxMintAmountPerWalletSet,
uint256 totalSupplyMinted,
uint256 mintCost
) {
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMaxMintAmountPerWallet (uint256 _maxMintAmountPerWallet) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOwner (address newOwner) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| balanceOf(msg.sender)<maxMintAmountPerWallet,"Max mint per wallet exceeded!" | 451,150 | balanceOf(msg.sender)<maxMintAmountPerWallet |
"Exceeds maximum token supply." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "./ERC721S.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract NervousNFT is
ERC721Sequential,
ReentrancyGuard,
PaymentSplitter,
Ownable
{
using Strings for uint256;
using ECDSA for bytes32;
mapping(bytes => uint256) private usedTickets;
uint256 public immutable maxSupply;
uint256 public constant MINT_PRICE = 0.03 ether;
uint256 public constant MAX_MINTS = 10;
string public baseURI;
bool public mintingEnabled = true;
address public crossmint;
string public constant R =
"We are Nervous. Are you? Let us help you with your next NFT Project -> [email protected]";
constructor(
string memory name,
string memory symbol,
string memory _initBaseURI,
uint256 _maxSupply,
address[] memory payees,
uint256[] memory shares
) ERC721Sequential(name, symbol) PaymentSplitter(payees, shares) {
}
/* Minting */
function toggleMinting() public onlyOwner {
}
function mint(uint256 numTokens)
public
payable
nonReentrant
requireValidMint(numTokens, msg.sender)
{
}
function mintTo(uint256 numTokens, address to)
external
payable
nonReentrant
requireCrossmint
requireValidMint(numTokens, to)
{
}
function _mintTo(uint256 numTokens, address to) internal {
}
// /* Magic */
function magicMint(uint256 numTokens) external onlyOwner {
require(<FILL_ME>)
require(
numTokens > 0 && numTokens <= 100,
"Machine can dispense a minimum of 1, maximum of 100 tokens"
);
for (uint256 i = 0; i < numTokens; i++) {
_safeMint(msg.sender);
}
}
function magicGift(address[] calldata receivers) external onlyOwner {
}
function magicBatchGift(
address[] calldata receivers,
uint256[] calldata mintCounts
) external onlyOwner {
}
/* Utility */
/* URL Utility */
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory _baseTokenURI) external onlyOwner {
}
/* eth handlers */
function withdraw(address payable account) public virtual {
}
function withdrawERC20(IERC20 token, address to) external onlyOwner {
}
/* Crossmint */
function setCrossmint(address _crossmint) public onlyOwner {
}
/* Modifiers */
modifier requireValidMint(uint256 numTokens, address to) {
}
modifier requireCrossmint() {
}
}
| totalMinted()+numTokens<=maxSupply,"Exceeds maximum token supply." | 451,155 | totalMinted()+numTokens<=maxSupply |
"User should be admin" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheLostWalletToken is
ERC1155,
ERC1155Supply,
Ownable,
ReentrancyGuard
{
string public name = "TheLostWallet Token";
string public symbol = "LostWallet";
uint256 public constant EARLY = 0;
uint256 public constant STANDARD = 1;
uint256 public constant maxEarlySupply = 1000;
// Mapping each tokenTypeId with
mapping(uint256 => bool) _tokenActivated;
// Admin wallets : Allowed to sign for WL :
mapping(address => bool) _admins;
constructor() ERC1155("ipfs://QmQGMXdX1tjupU3yAdBXsyrnwV1hEjHhDiCzruVgHfFduc/{id}.json") {
}
////////////////////////////
// Admin functions :
function addAdmin(address a) public onlyAdmin {
}
function removeAdmin(address a) public onlyAdmin {
}
modifier onlyAdmin() {
require(<FILL_ME>)
if (_admins[msg.sender]) {
_;
}
}
function activateWeek(uint256 weekId) public onlyAdmin {
}
function deactivateWeek(uint256 weekId) public onlyAdmin {
}
// Let's do a withdraw ...
// Just in case somebody wants to put some ETH on this contract, don't want to block that here :'(
function withdrawMoney() external onlyAdmin nonReentrant {
}
function setURI(string memory newuri) public onlyAdmin {
}
//
////////////////////////////
////////////////////////////
// Mint functions :
function mint(
uint256 weekId,
uint8 v,
bytes32 r,
bytes32 s
) public {
}
//
////////////////////////////
////////////////////////////
// Making this tokens SBTs : Non transferable
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
//
////////////////////////////
////////////////////////////
// SECURITY
// Will be used to sign early : Only if on WL :
function checkSign(
uint256 weekId,
uint8 v,
bytes32 r,
bytes32 s
) private view returns (bool) {
}
//
////////////////////////////
}
| _admins[msg.sender],"User should be admin" | 451,241 | _admins[msg.sender] |
"This early token can only be minted by whitelisted users ;)" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheLostWalletToken is
ERC1155,
ERC1155Supply,
Ownable,
ReentrancyGuard
{
string public name = "TheLostWallet Token";
string public symbol = "LostWallet";
uint256 public constant EARLY = 0;
uint256 public constant STANDARD = 1;
uint256 public constant maxEarlySupply = 1000;
// Mapping each tokenTypeId with
mapping(uint256 => bool) _tokenActivated;
// Admin wallets : Allowed to sign for WL :
mapping(address => bool) _admins;
constructor() ERC1155("ipfs://QmQGMXdX1tjupU3yAdBXsyrnwV1hEjHhDiCzruVgHfFduc/{id}.json") {
}
////////////////////////////
// Admin functions :
function addAdmin(address a) public onlyAdmin {
}
function removeAdmin(address a) public onlyAdmin {
}
modifier onlyAdmin() {
}
function activateWeek(uint256 weekId) public onlyAdmin {
}
function deactivateWeek(uint256 weekId) public onlyAdmin {
}
// Let's do a withdraw ...
// Just in case somebody wants to put some ETH on this contract, don't want to block that here :'(
function withdrawMoney() external onlyAdmin nonReentrant {
}
function setURI(string memory newuri) public onlyAdmin {
}
//
////////////////////////////
////////////////////////////
// Mint functions :
function mint(
uint256 weekId,
uint8 v,
bytes32 r,
bytes32 s
) public {
require(weekId >= 0 && weekId < 25, "Incorrect weekId ;)");
uint256 earlyTokenId = (weekId == 0) ? 0 : (2 * weekId) - 1;
uint256 earlySupply = totalSupply(earlyTokenId);
// Check sign :
require(<FILL_ME>)
// 1 token max / wallet
require(
this.balanceOf(msg.sender, earlyTokenId) == 0,
"You cannot mint more than one token of each week."
);
require(
weekId == 0 || this.balanceOf(msg.sender, earlyTokenId + 1) == 0,
"You cannot mint more than one token of each week."
);
require(
_tokenActivated[earlyTokenId],
"This token must activated first ..."
);
if (weekId == 0 || earlySupply < maxEarlySupply) {
// Mint early token :
_mint(msg.sender, earlyTokenId, 1, "");
} else {
// Mint std token :
_mint(msg.sender, earlyTokenId + 1, 1, "");
}
}
//
////////////////////////////
////////////////////////////
// Making this tokens SBTs : Non transferable
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
//
////////////////////////////
////////////////////////////
// SECURITY
// Will be used to sign early : Only if on WL :
function checkSign(
uint256 weekId,
uint8 v,
bytes32 r,
bytes32 s
) private view returns (bool) {
}
//
////////////////////////////
}
| checkSign(weekId,v,r,s),"This early token can only be minted by whitelisted users ;)" | 451,241 | checkSign(weekId,v,r,s) |
"You cannot mint more than one token of each week." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheLostWalletToken is
ERC1155,
ERC1155Supply,
Ownable,
ReentrancyGuard
{
string public name = "TheLostWallet Token";
string public symbol = "LostWallet";
uint256 public constant EARLY = 0;
uint256 public constant STANDARD = 1;
uint256 public constant maxEarlySupply = 1000;
// Mapping each tokenTypeId with
mapping(uint256 => bool) _tokenActivated;
// Admin wallets : Allowed to sign for WL :
mapping(address => bool) _admins;
constructor() ERC1155("ipfs://QmQGMXdX1tjupU3yAdBXsyrnwV1hEjHhDiCzruVgHfFduc/{id}.json") {
}
////////////////////////////
// Admin functions :
function addAdmin(address a) public onlyAdmin {
}
function removeAdmin(address a) public onlyAdmin {
}
modifier onlyAdmin() {
}
function activateWeek(uint256 weekId) public onlyAdmin {
}
function deactivateWeek(uint256 weekId) public onlyAdmin {
}
// Let's do a withdraw ...
// Just in case somebody wants to put some ETH on this contract, don't want to block that here :'(
function withdrawMoney() external onlyAdmin nonReentrant {
}
function setURI(string memory newuri) public onlyAdmin {
}
//
////////////////////////////
////////////////////////////
// Mint functions :
function mint(
uint256 weekId,
uint8 v,
bytes32 r,
bytes32 s
) public {
require(weekId >= 0 && weekId < 25, "Incorrect weekId ;)");
uint256 earlyTokenId = (weekId == 0) ? 0 : (2 * weekId) - 1;
uint256 earlySupply = totalSupply(earlyTokenId);
// Check sign :
require(
checkSign(weekId, v, r, s),
"This early token can only be minted by whitelisted users ;)"
);
// 1 token max / wallet
require(<FILL_ME>)
require(
weekId == 0 || this.balanceOf(msg.sender, earlyTokenId + 1) == 0,
"You cannot mint more than one token of each week."
);
require(
_tokenActivated[earlyTokenId],
"This token must activated first ..."
);
if (weekId == 0 || earlySupply < maxEarlySupply) {
// Mint early token :
_mint(msg.sender, earlyTokenId, 1, "");
} else {
// Mint std token :
_mint(msg.sender, earlyTokenId + 1, 1, "");
}
}
//
////////////////////////////
////////////////////////////
// Making this tokens SBTs : Non transferable
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
//
////////////////////////////
////////////////////////////
// SECURITY
// Will be used to sign early : Only if on WL :
function checkSign(
uint256 weekId,
uint8 v,
bytes32 r,
bytes32 s
) private view returns (bool) {
}
//
////////////////////////////
}
| this.balanceOf(msg.sender,earlyTokenId)==0,"You cannot mint more than one token of each week." | 451,241 | this.balanceOf(msg.sender,earlyTokenId)==0 |
"This token must activated first ..." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract TheLostWalletToken is
ERC1155,
ERC1155Supply,
Ownable,
ReentrancyGuard
{
string public name = "TheLostWallet Token";
string public symbol = "LostWallet";
uint256 public constant EARLY = 0;
uint256 public constant STANDARD = 1;
uint256 public constant maxEarlySupply = 1000;
// Mapping each tokenTypeId with
mapping(uint256 => bool) _tokenActivated;
// Admin wallets : Allowed to sign for WL :
mapping(address => bool) _admins;
constructor() ERC1155("ipfs://QmQGMXdX1tjupU3yAdBXsyrnwV1hEjHhDiCzruVgHfFduc/{id}.json") {
}
////////////////////////////
// Admin functions :
function addAdmin(address a) public onlyAdmin {
}
function removeAdmin(address a) public onlyAdmin {
}
modifier onlyAdmin() {
}
function activateWeek(uint256 weekId) public onlyAdmin {
}
function deactivateWeek(uint256 weekId) public onlyAdmin {
}
// Let's do a withdraw ...
// Just in case somebody wants to put some ETH on this contract, don't want to block that here :'(
function withdrawMoney() external onlyAdmin nonReentrant {
}
function setURI(string memory newuri) public onlyAdmin {
}
//
////////////////////////////
////////////////////////////
// Mint functions :
function mint(
uint256 weekId,
uint8 v,
bytes32 r,
bytes32 s
) public {
require(weekId >= 0 && weekId < 25, "Incorrect weekId ;)");
uint256 earlyTokenId = (weekId == 0) ? 0 : (2 * weekId) - 1;
uint256 earlySupply = totalSupply(earlyTokenId);
// Check sign :
require(
checkSign(weekId, v, r, s),
"This early token can only be minted by whitelisted users ;)"
);
// 1 token max / wallet
require(
this.balanceOf(msg.sender, earlyTokenId) == 0,
"You cannot mint more than one token of each week."
);
require(
weekId == 0 || this.balanceOf(msg.sender, earlyTokenId + 1) == 0,
"You cannot mint more than one token of each week."
);
require(<FILL_ME>)
if (weekId == 0 || earlySupply < maxEarlySupply) {
// Mint early token :
_mint(msg.sender, earlyTokenId, 1, "");
} else {
// Mint std token :
_mint(msg.sender, earlyTokenId + 1, 1, "");
}
}
//
////////////////////////////
////////////////////////////
// Making this tokens SBTs : Non transferable
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override(ERC1155, ERC1155Supply) {
}
//
////////////////////////////
////////////////////////////
// SECURITY
// Will be used to sign early : Only if on WL :
function checkSign(
uint256 weekId,
uint8 v,
bytes32 r,
bytes32 s
) private view returns (bool) {
}
//
////////////////////////////
}
| _tokenActivated[earlyTokenId],"This token must activated first ..." | 451,241 | _tokenActivated[earlyTokenId] |
"Not enough NFT left to mint!" | // SPDX-License-Identifier: MIT
/// @title Zoomers contract
/// @author zhs team
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Zoomersnft is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
bool public paused = true;
bool public publicSale = false;
bytes32 public OgMRoot;
bytes32 public WlMRoot;
Counters.Counter private IndexOfMint;
string private _baseTokenURI;
uint8 public maxMintAmountPerTx = 5;
uint8 public maxPerWallet = 2;
uint256 public cost = 0 ether;
uint32 public totalSupply = 3333;
mapping(address => uint8) public totalMintByUser;
constructor() ERC721("Zoomersnft", "zhs") {}
/// @dev modifer for mint conditions, which includes both public and whitelist sale.
modifier mintConditions(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
) {
require(!paused, "Zoomers contract is paused!");
require(
_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx,
"Invalid mint amount! should be greater than 0 and less than 6"
);
require(<FILL_ME>)
if (!publicSale) {
if (
MerkleProof.verify(
_merkleProof,
OgMRoot,
keccak256(abi.encodePacked(msg.sender))
)
) {
require(
totalMintByUser[msg.sender] + _mintAmount <= 5,
"OG cannot hold or mint more than 5 NFT in presale"
);
} else if (
MerkleProof.verify(
_merkleProof,
WlMRoot,
keccak256(abi.encodePacked(msg.sender))
)
) {
require(
totalMintByUser[msg.sender] + _mintAmount <= 3,
"Zhs Whitelist cannot hold or mint more than 3 NFT in presale"
);
} else {
revert(
"You are not in Zoomers OG or WL please wait for public sale to start"
);
}
}
_;
}
function setPaused(bool _state) external onlyOwner {
}
function setPublicState(bool _state) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setOgMRoot(bytes32 _OgMRoot) external onlyOwner {
}
function setWlMRoot(bytes32 _WlMRoot) external onlyOwner {
}
function mint(uint256 _mintAmount, bytes32[] calldata _merkleProof)
public
payable
mintConditions(_mintAmount, _merkleProof)
{
}
/// @notice n nfts reserved for future marketing campagins
function devMint(uint256 _mintAmount) external onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintquantity) internal {
}
function totalMinted() public view returns (uint256) {
}
/// @dev walletofOwner - IRC721 over written to save some gas.
/// @return tokens id owned by the given address
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function withdraw() external onlyOwner nonReentrant {
}
}
| IndexOfMint.current()+_mintAmount<=totalSupply,"Not enough NFT left to mint!" | 451,250 | IndexOfMint.current()+_mintAmount<=totalSupply |
"OG cannot hold or mint more than 5 NFT in presale" | // SPDX-License-Identifier: MIT
/// @title Zoomers contract
/// @author zhs team
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Zoomersnft is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
bool public paused = true;
bool public publicSale = false;
bytes32 public OgMRoot;
bytes32 public WlMRoot;
Counters.Counter private IndexOfMint;
string private _baseTokenURI;
uint8 public maxMintAmountPerTx = 5;
uint8 public maxPerWallet = 2;
uint256 public cost = 0 ether;
uint32 public totalSupply = 3333;
mapping(address => uint8) public totalMintByUser;
constructor() ERC721("Zoomersnft", "zhs") {}
/// @dev modifer for mint conditions, which includes both public and whitelist sale.
modifier mintConditions(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
) {
require(!paused, "Zoomers contract is paused!");
require(
_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx,
"Invalid mint amount! should be greater than 0 and less than 6"
);
require(
IndexOfMint.current() + _mintAmount <= totalSupply,
"Not enough NFT left to mint!"
);
if (!publicSale) {
if (
MerkleProof.verify(
_merkleProof,
OgMRoot,
keccak256(abi.encodePacked(msg.sender))
)
) {
require(<FILL_ME>)
} else if (
MerkleProof.verify(
_merkleProof,
WlMRoot,
keccak256(abi.encodePacked(msg.sender))
)
) {
require(
totalMintByUser[msg.sender] + _mintAmount <= 3,
"Zhs Whitelist cannot hold or mint more than 3 NFT in presale"
);
} else {
revert(
"You are not in Zoomers OG or WL please wait for public sale to start"
);
}
}
_;
}
function setPaused(bool _state) external onlyOwner {
}
function setPublicState(bool _state) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setOgMRoot(bytes32 _OgMRoot) external onlyOwner {
}
function setWlMRoot(bytes32 _WlMRoot) external onlyOwner {
}
function mint(uint256 _mintAmount, bytes32[] calldata _merkleProof)
public
payable
mintConditions(_mintAmount, _merkleProof)
{
}
/// @notice n nfts reserved for future marketing campagins
function devMint(uint256 _mintAmount) external onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintquantity) internal {
}
function totalMinted() public view returns (uint256) {
}
/// @dev walletofOwner - IRC721 over written to save some gas.
/// @return tokens id owned by the given address
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function withdraw() external onlyOwner nonReentrant {
}
}
| totalMintByUser[msg.sender]+_mintAmount<=5,"OG cannot hold or mint more than 5 NFT in presale" | 451,250 | totalMintByUser[msg.sender]+_mintAmount<=5 |
"Zhs Whitelist cannot hold or mint more than 3 NFT in presale" | // SPDX-License-Identifier: MIT
/// @title Zoomers contract
/// @author zhs team
pragma solidity ^0.8.6;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Zoomersnft is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
bool public paused = true;
bool public publicSale = false;
bytes32 public OgMRoot;
bytes32 public WlMRoot;
Counters.Counter private IndexOfMint;
string private _baseTokenURI;
uint8 public maxMintAmountPerTx = 5;
uint8 public maxPerWallet = 2;
uint256 public cost = 0 ether;
uint32 public totalSupply = 3333;
mapping(address => uint8) public totalMintByUser;
constructor() ERC721("Zoomersnft", "zhs") {}
/// @dev modifer for mint conditions, which includes both public and whitelist sale.
modifier mintConditions(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
) {
require(!paused, "Zoomers contract is paused!");
require(
_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx,
"Invalid mint amount! should be greater than 0 and less than 6"
);
require(
IndexOfMint.current() + _mintAmount <= totalSupply,
"Not enough NFT left to mint!"
);
if (!publicSale) {
if (
MerkleProof.verify(
_merkleProof,
OgMRoot,
keccak256(abi.encodePacked(msg.sender))
)
) {
require(
totalMintByUser[msg.sender] + _mintAmount <= 5,
"OG cannot hold or mint more than 5 NFT in presale"
);
} else if (
MerkleProof.verify(
_merkleProof,
WlMRoot,
keccak256(abi.encodePacked(msg.sender))
)
) {
require(<FILL_ME>)
} else {
revert(
"You are not in Zoomers OG or WL please wait for public sale to start"
);
}
}
_;
}
function setPaused(bool _state) external onlyOwner {
}
function setPublicState(bool _state) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function setOgMRoot(bytes32 _OgMRoot) external onlyOwner {
}
function setWlMRoot(bytes32 _WlMRoot) external onlyOwner {
}
function mint(uint256 _mintAmount, bytes32[] calldata _merkleProof)
public
payable
mintConditions(_mintAmount, _merkleProof)
{
}
/// @notice n nfts reserved for future marketing campagins
function devMint(uint256 _mintAmount) external onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintquantity) internal {
}
function totalMinted() public view returns (uint256) {
}
/// @dev walletofOwner - IRC721 over written to save some gas.
/// @return tokens id owned by the given address
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function withdraw() external onlyOwner nonReentrant {
}
}
| totalMintByUser[msg.sender]+_mintAmount<=3,"Zhs Whitelist cannot hold or mint more than 3 NFT in presale" | 451,250 | totalMintByUser[msg.sender]+_mintAmount<=3 |
"The address is not approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "../../eip712/NativeMetaTransaction.sol";
import "../../eip712/ContextMixin.sol";
import "./ERC721APausable.sol";
contract Human is
ERC721A,
ERC721ABurnable,
ERC721AQueryable,
ERC721APausable,
AccessControl,
Ownable,
ContextMixin,
NativeMetaTransaction
{
// Create a new role identifier for the minter role
bytes32 public constant MINER_ROLE = keccak256("MINER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
// using Counters for Counters.Counter;
// Counters.Counter private currentTokenId;
/// @dev Base token URI used as a prefix by tokenURI().
string private baseTokenURI;
string private collectionURI;
mapping(address => bool) public disapprovedMarketplaces;
constructor() ERC721A("NeymarJR", "NJR") {
}
function mintTo(address to) public onlyRole(MINER_ROLE) {
}
function mint(address to, uint256 quantity) public onlyRole(MINER_ROLE) {
}
function setDisapprovedMarketplace(address market, bool isDisapprove)
external
onlyRole(MINER_ROLE)
{
}
function approve(address to, uint256 tokenId)
public
payable
virtual
override
{
require(<FILL_ME>)
super.approve(to, tokenId);
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
/**
* @dev Pauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
}
function current() public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory _contractURI)
public
onlyRole(MINER_ROLE)
{
}
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI)
public
onlyRole(MINER_ROLE)
{
}
function transferRoleAdmin(address newDefaultAdmin)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function grantMinerRole(address _miner) external onlyOwner {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControl, ERC721A)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override(ERC721A, ERC721APausable) {
}
function _msgSenderERC721A()
internal
view
virtual
override
returns (address sender)
{
}
}
| !disapprovedMarketplaces[to],"The address is not approved" | 451,400 | !disapprovedMarketplaces[to] |
"The address is not approved" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "../../eip712/NativeMetaTransaction.sol";
import "../../eip712/ContextMixin.sol";
import "./ERC721APausable.sol";
contract Human is
ERC721A,
ERC721ABurnable,
ERC721AQueryable,
ERC721APausable,
AccessControl,
Ownable,
ContextMixin,
NativeMetaTransaction
{
// Create a new role identifier for the minter role
bytes32 public constant MINER_ROLE = keccak256("MINER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
// using Counters for Counters.Counter;
// Counters.Counter private currentTokenId;
/// @dev Base token URI used as a prefix by tokenURI().
string private baseTokenURI;
string private collectionURI;
mapping(address => bool) public disapprovedMarketplaces;
constructor() ERC721A("NeymarJR", "NJR") {
}
function mintTo(address to) public onlyRole(MINER_ROLE) {
}
function mint(address to, uint256 quantity) public onlyRole(MINER_ROLE) {
}
function setDisapprovedMarketplace(address market, bool isDisapprove)
external
onlyRole(MINER_ROLE)
{
}
function approve(address to, uint256 tokenId)
public
payable
virtual
override
{
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
require(<FILL_ME>)
super.setApprovalForAll(operator, approved);
}
/**
* @dev Pauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
}
function current() public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory _contractURI)
public
onlyRole(MINER_ROLE)
{
}
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI)
public
onlyRole(MINER_ROLE)
{
}
function transferRoleAdmin(address newDefaultAdmin)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function grantMinerRole(address _miner) external onlyOwner {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControl, ERC721A)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override(ERC721A, ERC721APausable) {
}
function _msgSenderERC721A()
internal
view
virtual
override
returns (address sender)
{
}
}
| !disapprovedMarketplaces[operator],"The address is not approved" | 451,400 | !disapprovedMarketplaces[operator] |
"HUMAN: must have pauser role to pause" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
import "erc721a/contracts/ERC721A.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "../../eip712/NativeMetaTransaction.sol";
import "../../eip712/ContextMixin.sol";
import "./ERC721APausable.sol";
contract Human is
ERC721A,
ERC721ABurnable,
ERC721AQueryable,
ERC721APausable,
AccessControl,
Ownable,
ContextMixin,
NativeMetaTransaction
{
// Create a new role identifier for the minter role
bytes32 public constant MINER_ROLE = keccak256("MINER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
// using Counters for Counters.Counter;
// Counters.Counter private currentTokenId;
/// @dev Base token URI used as a prefix by tokenURI().
string private baseTokenURI;
string private collectionURI;
mapping(address => bool) public disapprovedMarketplaces;
constructor() ERC721A("NeymarJR", "NJR") {
}
function mintTo(address to) public onlyRole(MINER_ROLE) {
}
function mint(address to, uint256 quantity) public onlyRole(MINER_ROLE) {
}
function setDisapprovedMarketplace(address market, bool isDisapprove)
external
onlyRole(MINER_ROLE)
{
}
function approve(address to, uint256 tokenId)
public
payable
virtual
override
{
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
}
/**
* @dev Pauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_pause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function pause() public virtual {
require(<FILL_ME>)
_pause();
}
/**
* @dev Unpauses all token transfers.
*
* See {ERC721Pausable} and {Pausable-_unpause}.
*
* Requirements:
*
* - the caller must have the `PAUSER_ROLE`.
*/
function unpause() public virtual {
}
function current() public view returns (uint256) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function contractURI() public view returns (string memory) {
}
function setContractURI(string memory _contractURI)
public
onlyRole(MINER_ROLE)
{
}
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI)
public
onlyRole(MINER_ROLE)
{
}
function transferRoleAdmin(address newDefaultAdmin)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
}
function grantMinerRole(address _miner) external onlyOwner {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(AccessControl, ERC721A)
returns (bool)
{
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override(ERC721A, ERC721APausable) {
}
function _msgSenderERC721A()
internal
view
virtual
override
returns (address sender)
{
}
}
| hasRole(PAUSER_ROLE,_msgSenderERC721A()),"HUMAN: must have pauser role to pause" | 451,400 | hasRole(PAUSER_ROLE,_msgSenderERC721A()) |
"GovernorAlpha::propose: proposer votes below proposal threshold" | // COPIED FROM https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/GovernorAlpha.sol
// Copyright 2020 Compound Labs, Inc.
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Ctrl+f for XXX to see all the modifications.
// uint96s are changed to uint256s for simplicity and safety.
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "./Converter.sol";
import "./ConverterGovernorAlphaConfig.sol";
contract ConverterGovernorAlpha {
/// @notice The name of this contract
// XXX: string public constant name = "Compound Governor Alpha";
string public constant name = "uToken Governor Alpha";
/// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed
// XXX: function quorumVotes() public pure returns (uint) { return 400000e18; } // 400,000 = 4% of Comp
function quorumVotes() public view returns (uint) { }
/// @notice The number of votes required in order for a voter to become a proposer
// XXX: function proposalThreshold() public pure returns (uint) { return 100000e18; } // 100,000 = 1% of Comp
function proposalThreshold() public view returns (uint) { }
/// @notice The maximum number of actions that can be included in a proposal
// XXX: function proposalMaxOperations() public pure returns (uint) { return 10; }
function proposalMaxOperations() public returns (uint) { }
/// @notice The delay before voting on a proposal may take place, once proposed
// XXX: function votingDelay() public pure returns (uint) { return 1; } // 1 block
function votingDelay() public returns (uint) { }
/// @notice The duration of voting on a proposal, in blocks
// XXX: function votingPeriod() public pure returns (uint) { return 17280; } // ~3 days in blocks (assuming 15s blocks)
function votingPeriod() public returns (uint) { }
ConverterGovernorAlphaConfig public config;
/// @notice The address of the Compound Protocol TimeLock
TimeLockInterface public timelock;
/// @notice The address of the uToken
// XXX: CompInterface public comp;
Converter public uToken;
/// @notice The address of the Governor Guardian
address public guardian;
/// @notice The total number of proposals
uint public proposalCount;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint id;
/// @notice Creator of the proposal
address proposer;
/// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
uint eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint endBlock;
/// @notice Current number of votes in favor of this proposal
uint forVotes;
/// @notice Current number of votes in opposition to this proposal
uint againstVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping (address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal
bool support;
/// @notice The number of votes the voter had, which were cast
uint256 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed
}
/// @notice The official record of all proposals ever proposed
mapping (uint => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping (address => uint) public latestProposalIds;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the ballot struct used by the contract
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
/// @notice An event emitted when a vote has been cast on a proposal
event VoteCast(address voter, uint proposalId, bool support, uint votes);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint id);
/// @notice An event emitted when a proposal has been queued in the TimeLock
event ProposalQueued(uint id, uint eta);
/// @notice An event emitted when a proposal has been executed in the TimeLock
event ProposalExecuted(uint id);
constructor(address timelock_, address _uToken, address guardian_, address _config) public {
}
/**
* Add a proposal. The proposer's voting power must exceed the threshold, and only one active proposal is allowed per user.
*/
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(<FILL_ME>)
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
}
uint startBlock = add256(block.number, votingDelay());
uint endBlock = add256(startBlock, votingPeriod());
proposalCount++;
Proposal memory newProposal = Proposal({
id: proposalCount,
proposer: msg.sender,
eta: 0,
targets: targets,
values: values,
signatures: signatures,
calldatas: calldatas,
startBlock: startBlock,
endBlock: endBlock,
forVotes: 0,
againstVotes: 0,
canceled: false,
executed: false
});
proposals[newProposal.id] = newProposal;
latestProposalIds[newProposal.proposer] = newProposal.id;
emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return newProposal.id;
}
/**
* Place a proposal in the ConverterTimeLock queue when the voting period has expired and the voting was successful.
*/
function queue(uint proposalId) public {
}
function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
}
/**
* Executes a proposal when it has been queued and the waiting time has expired.
*/
function execute(uint proposalId) public payable {
}
/**
* Proposals can be canceled by the creator of the collection or if the voting power of the proposer falls below the threshold.
*/
function cancel(uint proposalId) public {
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
}
function state(uint proposalId) public view returns (ProposalState) {
}
function castVote(uint proposalId, bool support) public {
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
}
function _castVote(address voter, uint proposalId, bool support) internal {
}
function __abdicate() public {
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
}
function getChainId() internal pure returns (uint) {
}
}
interface TimeLockInterface {
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}
| uToken.getPriorVotes(msg.sender,sub256(block.number,1))>proposalThreshold(),"GovernorAlpha::propose: proposer votes below proposal threshold" | 451,466 | uToken.getPriorVotes(msg.sender,sub256(block.number,1))>proposalThreshold() |
"not owner nor approved" | // SPDX-License-Identifier: MIT
/*******************************************
Website: https://warcraftx.com/
Twitter: https://twitter.com/WarcraftETH
Discord: https://discord.gg/rrT4sQgXQx
Telegram: https://t.me/WarcraftETH
********************************************/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Counters {
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
function reset(Counter storage counter) internal {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
library Address {
// Use extcodesize to judge whether an address is a contract address
function isContract(address account) internal view returns (bool) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
}
}
contract WoW is IERC721, IERC721Metadata, Ownable{
using Address for address;
using Strings for uint256;
string public override name;
string public override symbol;
string private _baseURI;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
mapping(uint => address) private _owners;
mapping(address => uint) private _balances;
mapping(uint => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
event BaseURIChanged(string newURI);
constructor(string memory url) {
}
function mint(address receiver) public onlyOwner{
}
function setBaseURI(string memory newURI) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function withdraw() public onlyOwner{
}
function destroy() public onlyOwner {
}
/***************************************/
function supportsInterface(bytes4 interfaceId) external pure override returns (bool) {
}
function balanceOf(address owner) public view override returns (uint) {
}
function ownerOf(uint tokenId) public view override returns (address owner) {
}
function isApprovedForAll(address owner, address operator) external view override returns (bool){
}
function setApprovalForAll(address operator, bool approved) external override {
}
function getApproved(uint tokenId) external view override returns (address) {
}
function _approve(address owner, address to,uint tokenId) private {
}
function approve(address to, uint tokenId) external override {
}
function _isApprovedOrOwner(address owner,address spender,uint tokenId) private view returns (bool) {
}
function _transfer(address owner,address from,address to,uint tokenId) private {
}
function transferFrom(address from,address to,uint tokenId) external override {
address owner = ownerOf(tokenId);
require(<FILL_ME>)
_transfer(owner, from, to, tokenId);
}
function _safeTransfer(address owner,address from,address to,uint tokenId,bytes memory _data) private {
}
function safeTransferFrom(address from,address to,uint tokenId,bytes memory _data) public override {
}
function safeTransferFrom(address from,address to,uint tokenId) external override {
}
function _mint(address to, uint tokenId) internal virtual {
}
function _burn(uint tokenId) internal virtual {
}
function _checkOnERC721Received(address from,address to,uint tokenId,bytes memory _data) private returns (bool) {
}
}
| _isApprovedOrOwner(owner,msg.sender,tokenId),"not owner nor approved" | 451,572 | _isApprovedOrOwner(owner,msg.sender,tokenId) |
"token already minted" | // SPDX-License-Identifier: MIT
/*******************************************
Website: https://warcraftx.com/
Twitter: https://twitter.com/WarcraftETH
Discord: https://discord.gg/rrT4sQgXQx
Telegram: https://t.me/WarcraftETH
********************************************/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Counters {
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
function reset(Counter storage counter) internal {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
library Address {
// Use extcodesize to judge whether an address is a contract address
function isContract(address account) internal view returns (bool) {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
}
}
contract WoW is IERC721, IERC721Metadata, Ownable{
using Address for address;
using Strings for uint256;
string public override name;
string public override symbol;
string private _baseURI;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
mapping(uint => address) private _owners;
mapping(address => uint) private _balances;
mapping(uint => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
event BaseURIChanged(string newURI);
constructor(string memory url) {
}
function mint(address receiver) public onlyOwner{
}
function setBaseURI(string memory newURI) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
function withdraw() public onlyOwner{
}
function destroy() public onlyOwner {
}
/***************************************/
function supportsInterface(bytes4 interfaceId) external pure override returns (bool) {
}
function balanceOf(address owner) public view override returns (uint) {
}
function ownerOf(uint tokenId) public view override returns (address owner) {
}
function isApprovedForAll(address owner, address operator) external view override returns (bool){
}
function setApprovalForAll(address operator, bool approved) external override {
}
function getApproved(uint tokenId) external view override returns (address) {
}
function _approve(address owner, address to,uint tokenId) private {
}
function approve(address to, uint tokenId) external override {
}
function _isApprovedOrOwner(address owner,address spender,uint tokenId) private view returns (bool) {
}
function _transfer(address owner,address from,address to,uint tokenId) private {
}
function transferFrom(address from,address to,uint tokenId) external override {
}
function _safeTransfer(address owner,address from,address to,uint tokenId,bytes memory _data) private {
}
function safeTransferFrom(address from,address to,uint tokenId,bytes memory _data) public override {
}
function safeTransferFrom(address from,address to,uint tokenId) external override {
}
function _mint(address to, uint tokenId) internal virtual {
require(to != address(0), "mint to zero address");
require(<FILL_ME>)
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint tokenId) internal virtual {
}
function _checkOnERC721Received(address from,address to,uint tokenId,bytes memory _data) private returns (bool) {
}
}
| _owners[tokenId]==address(0),"token already minted" | 451,572 | _owners[tokenId]==address(0) |
"trading not enabled" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "./Interfaces.sol";
abstract contract BaseErc20 is IERC20, IOwnable {
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
uint256 internal _totalSupply;
string public symbol;
string public name;
uint8 public decimals;
address public override owner;
address internal deployer;
bool public launched;
mapping (address => bool) internal exchanges;
modifier onlyOwner() {
}
modifier isLaunched() {
}
// @dev Trading is allowed before launch if the sender is the owner, we are transferring from the owner, or in canAlwaysTrade list
modifier tradingEnabled(address from) {
require(<FILL_ME>)
_;
}
function configure(address _owner) internal virtual {
}
/**
* @dev Total number of tokens in existence
*/
function totalSupply() external override view returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) external override view returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address spender) external override view returns (uint256) {
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) external override tradingEnabled(msg.sender) returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) external override tradingEnabled(msg.sender) returns (bool) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(address from, address to, uint256 value) external override tradingEnabled(from) returns (bool) {
}
// Virtual methods
function launch() virtual external onlyOwner {
}
function calculateTransferAmount(address from, address to, uint256 value) virtual internal returns (uint256) {
}
function preTransfer(address from, address to, uint256 value) virtual internal { }
// Admin methods
function changeOwner(address who) external onlyOwner {
}
function setExchange(address who, bool on) external onlyOwner {
}
// Private methods
function getRouterAddress() internal view returns (address routerAddress) {
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) private {
}
}
| launched||from==deployer,"trading not enabled" | 451,647 | launched||from==deployer |
"already set" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.7;
import "./Interfaces.sol";
abstract contract BaseErc20 is IERC20, IOwnable {
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
uint256 internal _totalSupply;
string public symbol;
string public name;
uint8 public decimals;
address public override owner;
address internal deployer;
bool public launched;
mapping (address => bool) internal exchanges;
modifier onlyOwner() {
}
modifier isLaunched() {
}
// @dev Trading is allowed before launch if the sender is the owner, we are transferring from the owner, or in canAlwaysTrade list
modifier tradingEnabled(address from) {
}
function configure(address _owner) internal virtual {
}
/**
* @dev Total number of tokens in existence
*/
function totalSupply() external override view returns (uint256) {
}
/**
* @dev Gets the balance of the specified address.
* @param _owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address _owner) external override view returns (uint256) {
}
/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @param _owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(address _owner, address spender) external override view returns (uint256) {
}
/**
* @dev Transfer token for a specified address
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) external override tradingEnabled(msg.sender) returns (bool) {
}
/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) external override tradingEnabled(msg.sender) returns (bool) {
}
/**
* @dev Transfer tokens from one address to another.
* Note that while this function emits an Approval event, this is not required as per the specification,
* and other compliant implementations may not emit the event.
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(address from, address to, uint256 value) external override tradingEnabled(from) returns (bool) {
}
// Virtual methods
function launch() virtual external onlyOwner {
}
function calculateTransferAmount(address from, address to, uint256 value) virtual internal returns (uint256) {
}
function preTransfer(address from, address to, uint256 value) virtual internal { }
// Admin methods
function changeOwner(address who) external onlyOwner {
}
function setExchange(address who, bool on) external onlyOwner {
require(<FILL_ME>)
exchanges[who] = on;
}
// Private methods
function getRouterAddress() internal view returns (address routerAddress) {
}
/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) private {
}
}
| exchanges[who]!=on,"already set" | 451,647 | exchanges[who]!=on |
'cannot zap and stake YDF only without lockup period' | /******************************************************************************************************
Staked YIELDFACTORY Liquidity (slYDF)
Website: https://yieldfactory.club
Twitter: https://twitter.com/yieldfactory
Telegram: https://t.me/yieldfactory
******************************************************************************************************/
pragma solidity ^0.8.9;
contract slYDF is YDFStake {
address private _uniswapRouter;
uint8 public zapBuySlippage = 2; // 2%
uint8 public zapSellSlippage = 25; // 25%
event StakeLiquidity(address indexed user, uint256 amountUniLPStaked);
event ZapETHOnly(
address indexed user,
uint256 amountETH,
uint256 amountUniLPStaked
);
event ZapYDFOnly(
address indexed user,
uint256 amountYDF,
uint256 amountUniLPStaked
);
event ZapETHAndYDF(
address indexed user,
uint256 amountETH,
uint256 amountYDF,
uint256 amountUniLPStaked
);
constructor(
address _pair,
address _router,
address _ydf,
address _vester,
address _rewards,
string memory _baseTokenURI
)
YDFStake(
'Staked YIELDFACTORY Liquidity',
'slYDF',
_pair,
_ydf,
_vester,
_rewards,
_baseTokenURI
)
{
}
function stake(uint256 _amount, uint256 _lockOptIndex) external override {
}
function zapAndStakeETHOnly(uint256 _lockOptIndex) external payable {
}
function zapAndStakeETHAndYDF(uint256 _amountYDF, uint256 _lockOptIndex)
external
payable
{
}
function zapAndStakeYDFOnly(uint256 _amountYDF, uint256 _lockOptIndex)
external
{
require(<FILL_ME>)
uint256 _ethBalBefore = address(this).balance;
uint256 _ydfBalBefore = ydf.balanceOf(address(this));
ydf.transferFrom(msg.sender, address(this), _amountYDF);
uint256 _ydfToProcess = ydf.balanceOf(address(this)) - _ydfBalBefore;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(_uniswapRouter);
// swap half the YDF for ETH
uint256 _ethToReceiveNoSlip = _getETHToReceiveOnSellNoSlippage(
_ydfToProcess / 2
);
address[] memory path = new address[](2);
path[0] = address(ydf);
path[1] = _uniswapV2Router.WETH();
ydf.approve(address(_uniswapV2Router), _ydfToProcess / 2);
_uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
_ydfToProcess / 2,
(_ethToReceiveNoSlip * (100 - zapSellSlippage)) / 100, // handle slippage
path,
address(this),
block.timestamp
);
uint256 _lpBalBefore = stakeToken.balanceOf(address(this));
_addLp(_ydfToProcess / 2, address(this).balance - _ethBalBefore);
uint256 _lpBalanceToStake = stakeToken.balanceOf(address(this)) -
_lpBalBefore;
_stakeLp(msg.sender, _lpBalanceToStake, _lockOptIndex, false);
_returnExcessETH(msg.sender, _ethBalBefore);
_returnExcessYDF(msg.sender, _ydfBalBefore);
emit ZapYDFOnly(msg.sender, _amountYDF, _lpBalanceToStake);
}
function _addLp(uint256 tokenAmount, uint256 ethAmount) private {
}
function _getTokensToReceiveOnBuyNoSlippage(uint256 _amountETH)
internal
view
returns (uint256)
{
}
function _getETHToReceiveOnSellNoSlippage(uint256 _amountYDF)
internal
view
returns (uint256)
{
}
function _stakeLp(
address _user,
uint256 _amountStakeToken,
uint256 _lockOptIndex,
bool _transferStakeToken
) internal {
}
function _returnExcessETH(address _user, uint256 _initialBal) internal {
}
function _returnExcessYDF(address _user, uint256 _initialBal) internal {
}
function setZapBuySlippage(uint8 _slippage) external onlyOwner {
}
function setZapSellSlippage(uint8 _slippage) external onlyOwner {
}
receive() external payable {}
}
| _aprLockOptions[_lockOptIndex].lockTime>0,'cannot zap and stake YDF only without lockup period' | 451,727 | _aprLockOptions[_lockOptIndex].lockTime>0 |
'took too much' | /******************************************************************************************************
Staked YIELDFACTORY Liquidity (slYDF)
Website: https://yieldfactory.club
Twitter: https://twitter.com/yieldfactory
Telegram: https://t.me/yieldfactory
******************************************************************************************************/
pragma solidity ^0.8.9;
contract slYDF is YDFStake {
address private _uniswapRouter;
uint8 public zapBuySlippage = 2; // 2%
uint8 public zapSellSlippage = 25; // 25%
event StakeLiquidity(address indexed user, uint256 amountUniLPStaked);
event ZapETHOnly(
address indexed user,
uint256 amountETH,
uint256 amountUniLPStaked
);
event ZapYDFOnly(
address indexed user,
uint256 amountYDF,
uint256 amountUniLPStaked
);
event ZapETHAndYDF(
address indexed user,
uint256 amountETH,
uint256 amountYDF,
uint256 amountUniLPStaked
);
constructor(
address _pair,
address _router,
address _ydf,
address _vester,
address _rewards,
string memory _baseTokenURI
)
YDFStake(
'Staked YIELDFACTORY Liquidity',
'slYDF',
_pair,
_ydf,
_vester,
_rewards,
_baseTokenURI
)
{
}
function stake(uint256 _amount, uint256 _lockOptIndex) external override {
}
function zapAndStakeETHOnly(uint256 _lockOptIndex) external payable {
}
function zapAndStakeETHAndYDF(uint256 _amountYDF, uint256 _lockOptIndex)
external
payable
{
}
function zapAndStakeYDFOnly(uint256 _amountYDF, uint256 _lockOptIndex)
external
{
}
function _addLp(uint256 tokenAmount, uint256 ethAmount) private {
}
function _getTokensToReceiveOnBuyNoSlippage(uint256 _amountETH)
internal
view
returns (uint256)
{
}
function _getETHToReceiveOnSellNoSlippage(uint256 _amountYDF)
internal
view
returns (uint256)
{
}
function _stakeLp(
address _user,
uint256 _amountStakeToken,
uint256 _lockOptIndex,
bool _transferStakeToken
) internal {
}
function _returnExcessETH(address _user, uint256 _initialBal) internal {
if (address(this).balance > _initialBal) {
payable(_user).call{ value: address(this).balance - _initialBal }('');
require(<FILL_ME>)
}
}
function _returnExcessYDF(address _user, uint256 _initialBal) internal {
}
function setZapBuySlippage(uint8 _slippage) external onlyOwner {
}
function setZapSellSlippage(uint8 _slippage) external onlyOwner {
}
receive() external payable {}
}
| address(this).balance>=_initialBal,'took too much' | 451,727 | address(this).balance>=_initialBal |
'took too much' | /******************************************************************************************************
Staked YIELDFACTORY Liquidity (slYDF)
Website: https://yieldfactory.club
Twitter: https://twitter.com/yieldfactory
Telegram: https://t.me/yieldfactory
******************************************************************************************************/
pragma solidity ^0.8.9;
contract slYDF is YDFStake {
address private _uniswapRouter;
uint8 public zapBuySlippage = 2; // 2%
uint8 public zapSellSlippage = 25; // 25%
event StakeLiquidity(address indexed user, uint256 amountUniLPStaked);
event ZapETHOnly(
address indexed user,
uint256 amountETH,
uint256 amountUniLPStaked
);
event ZapYDFOnly(
address indexed user,
uint256 amountYDF,
uint256 amountUniLPStaked
);
event ZapETHAndYDF(
address indexed user,
uint256 amountETH,
uint256 amountYDF,
uint256 amountUniLPStaked
);
constructor(
address _pair,
address _router,
address _ydf,
address _vester,
address _rewards,
string memory _baseTokenURI
)
YDFStake(
'Staked YIELDFACTORY Liquidity',
'slYDF',
_pair,
_ydf,
_vester,
_rewards,
_baseTokenURI
)
{
}
function stake(uint256 _amount, uint256 _lockOptIndex) external override {
}
function zapAndStakeETHOnly(uint256 _lockOptIndex) external payable {
}
function zapAndStakeETHAndYDF(uint256 _amountYDF, uint256 _lockOptIndex)
external
payable
{
}
function zapAndStakeYDFOnly(uint256 _amountYDF, uint256 _lockOptIndex)
external
{
}
function _addLp(uint256 tokenAmount, uint256 ethAmount) private {
}
function _getTokensToReceiveOnBuyNoSlippage(uint256 _amountETH)
internal
view
returns (uint256)
{
}
function _getETHToReceiveOnSellNoSlippage(uint256 _amountYDF)
internal
view
returns (uint256)
{
}
function _stakeLp(
address _user,
uint256 _amountStakeToken,
uint256 _lockOptIndex,
bool _transferStakeToken
) internal {
}
function _returnExcessETH(address _user, uint256 _initialBal) internal {
}
function _returnExcessYDF(address _user, uint256 _initialBal) internal {
uint256 _currentBal = ydf.balanceOf(address(this));
if (_currentBal > _initialBal) {
ydf.transfer(_user, _currentBal - _initialBal);
require(<FILL_ME>)
}
}
function setZapBuySlippage(uint8 _slippage) external onlyOwner {
}
function setZapSellSlippage(uint8 _slippage) external onlyOwner {
}
receive() external payable {}
}
| ydf.balanceOf(address(this))>=_initialBal,'took too much' | 451,727 | ydf.balanceOf(address(this))>=_initialBal |
"We're out. Go complain to 6969." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/*
%%%%% *%%%%% &#####@/. ######
%%%%%%%%%%%%%% &%#####%%%%%% ######
(%%%%%%%######((((((###%%#############((((((#####&
%%%%%%%%######((((((###%%#############((((((#####@
%%%%%%######((((((##(((########//////////////////////////////////,
%%%%%%%%%%%######((((((##((((######(//////////////////////////////////
%%%%%%%%%%#######(((((######%/ /////(((((((((((((((((((((((((((((((((((((((((
,%%%#######(((((########## (((((((((((((((((((((((((((((((((((((((((((((
%%######(((((((########## (((((((((((((((((((((((((((((((%@&&&&&%%&((((
#(#(((((((((((########## (((((&&&&&&&&&%#@((((((((((((((@&&&&&###@(((,
#(((((((((((((########## (((((&&&&&&&&&(#@((((((((((((((&#&&&&###@(((
@((((((((((######### (((((&&&&#%%##&&&&&%#(((((%&#####&&&&####(((
@#(((((((((#########/(((((&&&&#####&&&&&#(#((((@ &&&&###/(((
%#((((((((((((##########(((((&&&&@ (@@@#@@@%%@((((((((#&###((((
@#((((((((((((##########(((((@&&&##/(((((((((@@@##@((((((((@##@#((((
,##((((((((((/(#########(((((@&&&##/(((((((((%/&@@/(((((((((((((((((
##((((((((((((#########(((((/(((((((((((((((((((((((((((((((((((((
&(((((((((((#########((((((((((((((((((((((((((#(((( #%%#(((((((
(((((((((&#######((((((((((( #%*(((( (%#((((# %##(((((((,
((((((((((((((((#####((((((((((( %#,(((( ,//,#%%###((((
((((((((((((#(((#####((((((((((( %%%,##((((
%%%%(((######%%%%%((((( %##%%&&%#######% ###.
######## %#((((( &&& ################((
########/###(( &&&&&&&####%%& # %%#((
#########(((( *&&&&%&&##%%%&&&#####(((
######((((( *%&&%&&%&&%%% /&#% #(((/
####(((#( *&%%%%%%%&%%&%## /////
##((##(%%%%,&&%##*%%%((%### (((
##%%%%###### %%%#,((((##%#*(((
##%%%######%%# ((((((((((((
#########((((((((((((((
#####((((((/
*/
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract RugBurn is ERC721A, Ownable {
uint256 public maxSupply = 1000;
string public ipfsString = "QmXwAULH9BGq6tP8xQ66nQxrd9T28nsDZ11GaAx9JcbZLP";
string public ipfsExt = ".json";
constructor() ERC721A("RugBurn", "RBN") {}
// -- Mint + Airdrop function -- //
function mint(uint256 quantity) external payable {
require(msg.value >= 0.05 ether, "Not enough ETH sent: check price.");
require(<FILL_ME>)
_mint(msg.sender, quantity);
}
function batchTransfer(address[] calldata _addrs, uint256[] calldata _tokenIds) onlyOwner public {
}
// -- Other stuff -- //
function setIpfsString(string calldata _ipfsString, string calldata _ipfsExt) onlyOwner public {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
}
| (totalSupply()+quantity)<=maxSupply,"We're out. Go complain to 6969." | 452,082 | (totalSupply()+quantity)<=maxSupply |
"DadBros: Max supply reached" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8;
import "../ONFT721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "../../../libraries/OmniLinearCurve.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {toDaysWadUnsafe} from "solmate/src/utils/SignedWadMath.sol";
/// @title Interface of the AdvancedONFT standard
/// @author exakoss
/// @notice this implementation supports: batch mint, payable public and private mint, reveal of metadata and EIP-2981 on-chain royalties
contract DadBrosV2 is ERC721, ReentrancyGuard, Ownable, DefaultOperatorFilterer {
using Strings for uint;
using OmniLinearCurve for OmniLinearCurve.OmniCurve;
uint public tax = 1000; // 100% = 10000
uint16 public nextMintId = 1302;
/*//////////////////////////////////////////////////////////////
MINT CONSTANTS
//////////////////////////////////////////////////////////////*/
uint16 public constant MAX_MINT_ID_TOTAL = 3000;
uint16 public maxClaimId = 1302;
uint8 public MAX_TOKENS_PER_MINT_FRIENDS = 5;
uint8 public MAX_TOKENS_PER_MINT_PUBLIC = 20;
uint128 public MIN_PUBLIC_PRICE = 0.018 ether;
uint128 public MAX_PRICE_PUBLIC = 0.03 ether;
uint128 public FLAT_PRICE_FRIENDS = 0.01 ether;
uint128 public PRICE_DELTA_PUBLIC = 0.00008e18;
uint128 public PRICE_DECAY_PUBLIC= 0.002e18;
uint16 public friendsAndPublicSupply;
uint16 public claimSupply;
/*//////////////////////////////////////////////////////////////
MINT TYPES
//////////////////////////////////////////////////////////////*/
uint8 private constant MINT_FRIENDS_ID = 2;
uint8 private constant MINT_PUBLIC_ID = 3;
/*//////////////////////////////////////////////////////////////
MINTING STATE
//////////////////////////////////////////////////////////////*/
uint128 public spotPricePublic = 0.01992 ether;
uint256 public lastUpdatePublic = 0;
address payable beneficiary;
address payable taxRecipient;
bytes32 public merkleRootFriends;
bytes32 public merkleRootClaim;
string private baseURI;
bool public _saleStarted;
bool public revealed;
mapping (uint8 => mapping (address => uint16)) public minted;
mapping (address => bool) public claimed;
modifier onlyBeneficiaryAndOwner() {
}
/// @notice Constructor for the AdvancedONFT
/// @param _name the name of the token
/// @param _symbol the token symbol
/// @param _baseTokenURI the base URI for computing the tokenURI
/// @param _tax the tax percentage (100% = 10000)
/// @param _taxRecipient the address that receives the tax
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI,
uint _tax,
address _taxRecipient
)
ERC721(_name, _symbol)
{
}
function setTax(uint _tax) external onlyOwner {
}
function setTaxRecipient(address payable _taxRecipient) external onlyOwner {
}
/// @notice Mint functions for all 3 mint tiers
/// @param _nbTokens the number of tokens to mint (Friends: 1-5 Public: 1-20)
/// @param mintType the type of mint (2: Friends 3: Public)
/// @param _merkleProof the merkle proof
/// @param wlAllocationAmt the amount of tokens allocated to the address
function mint(uint16 _nbTokens, uint8 mintType, bytes32[] calldata _merkleProof, uint256 wlAllocationAmt) external payable {
require(_saleStarted == true, "DadBros: Sale has not started yet!");
require(_nbTokens > 0, "DadBros: Cannot mint 0 tokens");
require(<FILL_ME>)
require(mintType == MINT_FRIENDS_ID || mintType == MINT_PUBLIC_ID, "DadBros: Invalid mint type");
uint currMinted = minted[mintType][msg.sender];
uint128 newSpotPrice;
uint256 totalPrice;
if (mintType == MINT_FRIENDS_ID) {
require(currMinted + _nbTokens <= wlAllocationAmt, "DadBros: Max tokens per address reached");
require(_nbTokens <= MAX_TOKENS_PER_MINT_FRIENDS, "DadBros: Max tokens per mint reached");
{
bool isWl = MerkleProof.verify(_merkleProof, merkleRootFriends, keccak256(abi.encodePacked(_msgSender(), wlAllocationAmt)));
require(isWl == true, "DadBros: Invalid Merkle Proof");
}
require(msg.value >= FLAT_PRICE_FRIENDS * uint128(_nbTokens), "DadBros: Not enough ETH");
} else if (mintType == MINT_PUBLIC_ID) {
require(_nbTokens <= MAX_TOKENS_PER_MINT_PUBLIC, "DadBros: Max tokens per mint reached");
(newSpotPrice, totalPrice) = getPriceInfo(MINT_PUBLIC_ID, _nbTokens);
require(msg.value >= totalPrice, "DadBros: Not enough ETH");
}
uint16 localNextMintId = nextMintId;
for (uint16 i; i < _nbTokens; i++) {
_mint(msg.sender, ++localNextMintId);
}
nextMintId = localNextMintId;
minted[mintType][msg.sender] += _nbTokens;
if (mintType == MINT_PUBLIC_ID) {
spotPricePublic = newSpotPrice;
lastUpdatePublic = block.timestamp;
}
friendsAndPublicSupply += _nbTokens;
}
function claim(uint256[] memory tokenIds, address to, bytes32[] calldata _merkleProof) external {
}
/// @param mintType (2: Friends 3: Public)
/// @param amount (1-5 for Friends, 1-20 for Public)
/// @return new next spot price (in wei)
/// @return total price (in wei)
function getPriceInfo(uint8 mintType, uint16 amount) public view returns (uint128, uint256) {
}
function setMerkleRoot(bytes32 tier, bytes32 _merkleRoot) external onlyBeneficiaryAndOwner {
}
function setBaseURI(string memory uri) public onlyBeneficiaryAndOwner {
}
function setBeneficiary(address payable _beneficiary) external onlyOwner {
}
function flipRevealed() external onlyBeneficiaryAndOwner {
}
function flipSaleStarted() external onlyBeneficiaryAndOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMaxClaimId(uint16 _maxClaimId) external onlyBeneficiaryAndOwner {
}
function setMaxTokensPerMint(bytes32 _param, uint8 _value) external onlyBeneficiaryAndOwner {
}
function setPriceParams(bytes32 _param, uint128 _value) external onlyBeneficiaryAndOwner {
}
function setNextMintId(uint16 _nextMintId) external onlyBeneficiaryAndOwner {
}
function withdraw() public virtual onlyBeneficiaryAndOwner {
}
function tokenURI(uint tokenId) public view override(ERC721) returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| _nbTokens+nextMintId<=MAX_MINT_ID_TOTAL,"DadBros: Max supply reached" | 452,231 | _nbTokens+nextMintId<=MAX_MINT_ID_TOTAL |
"DadBros: Max tokens per address reached" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8;
import "../ONFT721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "../../../libraries/OmniLinearCurve.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {toDaysWadUnsafe} from "solmate/src/utils/SignedWadMath.sol";
/// @title Interface of the AdvancedONFT standard
/// @author exakoss
/// @notice this implementation supports: batch mint, payable public and private mint, reveal of metadata and EIP-2981 on-chain royalties
contract DadBrosV2 is ERC721, ReentrancyGuard, Ownable, DefaultOperatorFilterer {
using Strings for uint;
using OmniLinearCurve for OmniLinearCurve.OmniCurve;
uint public tax = 1000; // 100% = 10000
uint16 public nextMintId = 1302;
/*//////////////////////////////////////////////////////////////
MINT CONSTANTS
//////////////////////////////////////////////////////////////*/
uint16 public constant MAX_MINT_ID_TOTAL = 3000;
uint16 public maxClaimId = 1302;
uint8 public MAX_TOKENS_PER_MINT_FRIENDS = 5;
uint8 public MAX_TOKENS_PER_MINT_PUBLIC = 20;
uint128 public MIN_PUBLIC_PRICE = 0.018 ether;
uint128 public MAX_PRICE_PUBLIC = 0.03 ether;
uint128 public FLAT_PRICE_FRIENDS = 0.01 ether;
uint128 public PRICE_DELTA_PUBLIC = 0.00008e18;
uint128 public PRICE_DECAY_PUBLIC= 0.002e18;
uint16 public friendsAndPublicSupply;
uint16 public claimSupply;
/*//////////////////////////////////////////////////////////////
MINT TYPES
//////////////////////////////////////////////////////////////*/
uint8 private constant MINT_FRIENDS_ID = 2;
uint8 private constant MINT_PUBLIC_ID = 3;
/*//////////////////////////////////////////////////////////////
MINTING STATE
//////////////////////////////////////////////////////////////*/
uint128 public spotPricePublic = 0.01992 ether;
uint256 public lastUpdatePublic = 0;
address payable beneficiary;
address payable taxRecipient;
bytes32 public merkleRootFriends;
bytes32 public merkleRootClaim;
string private baseURI;
bool public _saleStarted;
bool public revealed;
mapping (uint8 => mapping (address => uint16)) public minted;
mapping (address => bool) public claimed;
modifier onlyBeneficiaryAndOwner() {
}
/// @notice Constructor for the AdvancedONFT
/// @param _name the name of the token
/// @param _symbol the token symbol
/// @param _baseTokenURI the base URI for computing the tokenURI
/// @param _tax the tax percentage (100% = 10000)
/// @param _taxRecipient the address that receives the tax
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI,
uint _tax,
address _taxRecipient
)
ERC721(_name, _symbol)
{
}
function setTax(uint _tax) external onlyOwner {
}
function setTaxRecipient(address payable _taxRecipient) external onlyOwner {
}
/// @notice Mint functions for all 3 mint tiers
/// @param _nbTokens the number of tokens to mint (Friends: 1-5 Public: 1-20)
/// @param mintType the type of mint (2: Friends 3: Public)
/// @param _merkleProof the merkle proof
/// @param wlAllocationAmt the amount of tokens allocated to the address
function mint(uint16 _nbTokens, uint8 mintType, bytes32[] calldata _merkleProof, uint256 wlAllocationAmt) external payable {
require(_saleStarted == true, "DadBros: Sale has not started yet!");
require(_nbTokens > 0, "DadBros: Cannot mint 0 tokens");
require(_nbTokens + nextMintId <= MAX_MINT_ID_TOTAL, "DadBros: Max supply reached");
require(mintType == MINT_FRIENDS_ID || mintType == MINT_PUBLIC_ID, "DadBros: Invalid mint type");
uint currMinted = minted[mintType][msg.sender];
uint128 newSpotPrice;
uint256 totalPrice;
if (mintType == MINT_FRIENDS_ID) {
require(<FILL_ME>)
require(_nbTokens <= MAX_TOKENS_PER_MINT_FRIENDS, "DadBros: Max tokens per mint reached");
{
bool isWl = MerkleProof.verify(_merkleProof, merkleRootFriends, keccak256(abi.encodePacked(_msgSender(), wlAllocationAmt)));
require(isWl == true, "DadBros: Invalid Merkle Proof");
}
require(msg.value >= FLAT_PRICE_FRIENDS * uint128(_nbTokens), "DadBros: Not enough ETH");
} else if (mintType == MINT_PUBLIC_ID) {
require(_nbTokens <= MAX_TOKENS_PER_MINT_PUBLIC, "DadBros: Max tokens per mint reached");
(newSpotPrice, totalPrice) = getPriceInfo(MINT_PUBLIC_ID, _nbTokens);
require(msg.value >= totalPrice, "DadBros: Not enough ETH");
}
uint16 localNextMintId = nextMintId;
for (uint16 i; i < _nbTokens; i++) {
_mint(msg.sender, ++localNextMintId);
}
nextMintId = localNextMintId;
minted[mintType][msg.sender] += _nbTokens;
if (mintType == MINT_PUBLIC_ID) {
spotPricePublic = newSpotPrice;
lastUpdatePublic = block.timestamp;
}
friendsAndPublicSupply += _nbTokens;
}
function claim(uint256[] memory tokenIds, address to, bytes32[] calldata _merkleProof) external {
}
/// @param mintType (2: Friends 3: Public)
/// @param amount (1-5 for Friends, 1-20 for Public)
/// @return new next spot price (in wei)
/// @return total price (in wei)
function getPriceInfo(uint8 mintType, uint16 amount) public view returns (uint128, uint256) {
}
function setMerkleRoot(bytes32 tier, bytes32 _merkleRoot) external onlyBeneficiaryAndOwner {
}
function setBaseURI(string memory uri) public onlyBeneficiaryAndOwner {
}
function setBeneficiary(address payable _beneficiary) external onlyOwner {
}
function flipRevealed() external onlyBeneficiaryAndOwner {
}
function flipSaleStarted() external onlyBeneficiaryAndOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMaxClaimId(uint16 _maxClaimId) external onlyBeneficiaryAndOwner {
}
function setMaxTokensPerMint(bytes32 _param, uint8 _value) external onlyBeneficiaryAndOwner {
}
function setPriceParams(bytes32 _param, uint128 _value) external onlyBeneficiaryAndOwner {
}
function setNextMintId(uint16 _nextMintId) external onlyBeneficiaryAndOwner {
}
function withdraw() public virtual onlyBeneficiaryAndOwner {
}
function tokenURI(uint tokenId) public view override(ERC721) returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| currMinted+_nbTokens<=wlAllocationAmt,"DadBros: Max tokens per address reached" | 452,231 | currMinted+_nbTokens<=wlAllocationAmt |
"DadBros: Already claimed" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8;
import "../ONFT721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "../../../libraries/OmniLinearCurve.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {toDaysWadUnsafe} from "solmate/src/utils/SignedWadMath.sol";
/// @title Interface of the AdvancedONFT standard
/// @author exakoss
/// @notice this implementation supports: batch mint, payable public and private mint, reveal of metadata and EIP-2981 on-chain royalties
contract DadBrosV2 is ERC721, ReentrancyGuard, Ownable, DefaultOperatorFilterer {
using Strings for uint;
using OmniLinearCurve for OmniLinearCurve.OmniCurve;
uint public tax = 1000; // 100% = 10000
uint16 public nextMintId = 1302;
/*//////////////////////////////////////////////////////////////
MINT CONSTANTS
//////////////////////////////////////////////////////////////*/
uint16 public constant MAX_MINT_ID_TOTAL = 3000;
uint16 public maxClaimId = 1302;
uint8 public MAX_TOKENS_PER_MINT_FRIENDS = 5;
uint8 public MAX_TOKENS_PER_MINT_PUBLIC = 20;
uint128 public MIN_PUBLIC_PRICE = 0.018 ether;
uint128 public MAX_PRICE_PUBLIC = 0.03 ether;
uint128 public FLAT_PRICE_FRIENDS = 0.01 ether;
uint128 public PRICE_DELTA_PUBLIC = 0.00008e18;
uint128 public PRICE_DECAY_PUBLIC= 0.002e18;
uint16 public friendsAndPublicSupply;
uint16 public claimSupply;
/*//////////////////////////////////////////////////////////////
MINT TYPES
//////////////////////////////////////////////////////////////*/
uint8 private constant MINT_FRIENDS_ID = 2;
uint8 private constant MINT_PUBLIC_ID = 3;
/*//////////////////////////////////////////////////////////////
MINTING STATE
//////////////////////////////////////////////////////////////*/
uint128 public spotPricePublic = 0.01992 ether;
uint256 public lastUpdatePublic = 0;
address payable beneficiary;
address payable taxRecipient;
bytes32 public merkleRootFriends;
bytes32 public merkleRootClaim;
string private baseURI;
bool public _saleStarted;
bool public revealed;
mapping (uint8 => mapping (address => uint16)) public minted;
mapping (address => bool) public claimed;
modifier onlyBeneficiaryAndOwner() {
}
/// @notice Constructor for the AdvancedONFT
/// @param _name the name of the token
/// @param _symbol the token symbol
/// @param _baseTokenURI the base URI for computing the tokenURI
/// @param _tax the tax percentage (100% = 10000)
/// @param _taxRecipient the address that receives the tax
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI,
uint _tax,
address _taxRecipient
)
ERC721(_name, _symbol)
{
}
function setTax(uint _tax) external onlyOwner {
}
function setTaxRecipient(address payable _taxRecipient) external onlyOwner {
}
/// @notice Mint functions for all 3 mint tiers
/// @param _nbTokens the number of tokens to mint (Friends: 1-5 Public: 1-20)
/// @param mintType the type of mint (2: Friends 3: Public)
/// @param _merkleProof the merkle proof
/// @param wlAllocationAmt the amount of tokens allocated to the address
function mint(uint16 _nbTokens, uint8 mintType, bytes32[] calldata _merkleProof, uint256 wlAllocationAmt) external payable {
}
function claim(uint256[] memory tokenIds, address to, bytes32[] calldata _merkleProof) external {
require(_saleStarted == true, "DadBros: claim has not started yet!");
require(<FILL_ME>)
require(tokenIds.length > 0, "DadBros: Cannot claim 0 tokens");
require(tokenIds.length + claimSupply <= maxClaimId, "DadBros: Max claim supply reached");
{
bool isWl = MerkleProof.verify(_merkleProof, merkleRootClaim, keccak256(abi.encodePacked(to, tokenIds)));
require(isWl == true, "DadBros: Invalid Merkle Proof");
}
for (uint16 i; i < tokenIds.length; i++) {
_mint(to, tokenIds[i]);
}
claimed[to] = true;
claimSupply += uint16(tokenIds.length);
}
/// @param mintType (2: Friends 3: Public)
/// @param amount (1-5 for Friends, 1-20 for Public)
/// @return new next spot price (in wei)
/// @return total price (in wei)
function getPriceInfo(uint8 mintType, uint16 amount) public view returns (uint128, uint256) {
}
function setMerkleRoot(bytes32 tier, bytes32 _merkleRoot) external onlyBeneficiaryAndOwner {
}
function setBaseURI(string memory uri) public onlyBeneficiaryAndOwner {
}
function setBeneficiary(address payable _beneficiary) external onlyOwner {
}
function flipRevealed() external onlyBeneficiaryAndOwner {
}
function flipSaleStarted() external onlyBeneficiaryAndOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMaxClaimId(uint16 _maxClaimId) external onlyBeneficiaryAndOwner {
}
function setMaxTokensPerMint(bytes32 _param, uint8 _value) external onlyBeneficiaryAndOwner {
}
function setPriceParams(bytes32 _param, uint128 _value) external onlyBeneficiaryAndOwner {
}
function setNextMintId(uint16 _nextMintId) external onlyBeneficiaryAndOwner {
}
function withdraw() public virtual onlyBeneficiaryAndOwner {
}
function tokenURI(uint tokenId) public view override(ERC721) returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| claimed[to]==false,"DadBros: Already claimed" | 452,231 | claimed[to]==false |
"DadBros: Max claim supply reached" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8;
import "../ONFT721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "../../../libraries/OmniLinearCurve.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {toDaysWadUnsafe} from "solmate/src/utils/SignedWadMath.sol";
/// @title Interface of the AdvancedONFT standard
/// @author exakoss
/// @notice this implementation supports: batch mint, payable public and private mint, reveal of metadata and EIP-2981 on-chain royalties
contract DadBrosV2 is ERC721, ReentrancyGuard, Ownable, DefaultOperatorFilterer {
using Strings for uint;
using OmniLinearCurve for OmniLinearCurve.OmniCurve;
uint public tax = 1000; // 100% = 10000
uint16 public nextMintId = 1302;
/*//////////////////////////////////////////////////////////////
MINT CONSTANTS
//////////////////////////////////////////////////////////////*/
uint16 public constant MAX_MINT_ID_TOTAL = 3000;
uint16 public maxClaimId = 1302;
uint8 public MAX_TOKENS_PER_MINT_FRIENDS = 5;
uint8 public MAX_TOKENS_PER_MINT_PUBLIC = 20;
uint128 public MIN_PUBLIC_PRICE = 0.018 ether;
uint128 public MAX_PRICE_PUBLIC = 0.03 ether;
uint128 public FLAT_PRICE_FRIENDS = 0.01 ether;
uint128 public PRICE_DELTA_PUBLIC = 0.00008e18;
uint128 public PRICE_DECAY_PUBLIC= 0.002e18;
uint16 public friendsAndPublicSupply;
uint16 public claimSupply;
/*//////////////////////////////////////////////////////////////
MINT TYPES
//////////////////////////////////////////////////////////////*/
uint8 private constant MINT_FRIENDS_ID = 2;
uint8 private constant MINT_PUBLIC_ID = 3;
/*//////////////////////////////////////////////////////////////
MINTING STATE
//////////////////////////////////////////////////////////////*/
uint128 public spotPricePublic = 0.01992 ether;
uint256 public lastUpdatePublic = 0;
address payable beneficiary;
address payable taxRecipient;
bytes32 public merkleRootFriends;
bytes32 public merkleRootClaim;
string private baseURI;
bool public _saleStarted;
bool public revealed;
mapping (uint8 => mapping (address => uint16)) public minted;
mapping (address => bool) public claimed;
modifier onlyBeneficiaryAndOwner() {
}
/// @notice Constructor for the AdvancedONFT
/// @param _name the name of the token
/// @param _symbol the token symbol
/// @param _baseTokenURI the base URI for computing the tokenURI
/// @param _tax the tax percentage (100% = 10000)
/// @param _taxRecipient the address that receives the tax
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI,
uint _tax,
address _taxRecipient
)
ERC721(_name, _symbol)
{
}
function setTax(uint _tax) external onlyOwner {
}
function setTaxRecipient(address payable _taxRecipient) external onlyOwner {
}
/// @notice Mint functions for all 3 mint tiers
/// @param _nbTokens the number of tokens to mint (Friends: 1-5 Public: 1-20)
/// @param mintType the type of mint (2: Friends 3: Public)
/// @param _merkleProof the merkle proof
/// @param wlAllocationAmt the amount of tokens allocated to the address
function mint(uint16 _nbTokens, uint8 mintType, bytes32[] calldata _merkleProof, uint256 wlAllocationAmt) external payable {
}
function claim(uint256[] memory tokenIds, address to, bytes32[] calldata _merkleProof) external {
require(_saleStarted == true, "DadBros: claim has not started yet!");
require(claimed[to] == false, "DadBros: Already claimed");
require(tokenIds.length > 0, "DadBros: Cannot claim 0 tokens");
require(<FILL_ME>)
{
bool isWl = MerkleProof.verify(_merkleProof, merkleRootClaim, keccak256(abi.encodePacked(to, tokenIds)));
require(isWl == true, "DadBros: Invalid Merkle Proof");
}
for (uint16 i; i < tokenIds.length; i++) {
_mint(to, tokenIds[i]);
}
claimed[to] = true;
claimSupply += uint16(tokenIds.length);
}
/// @param mintType (2: Friends 3: Public)
/// @param amount (1-5 for Friends, 1-20 for Public)
/// @return new next spot price (in wei)
/// @return total price (in wei)
function getPriceInfo(uint8 mintType, uint16 amount) public view returns (uint128, uint256) {
}
function setMerkleRoot(bytes32 tier, bytes32 _merkleRoot) external onlyBeneficiaryAndOwner {
}
function setBaseURI(string memory uri) public onlyBeneficiaryAndOwner {
}
function setBeneficiary(address payable _beneficiary) external onlyOwner {
}
function flipRevealed() external onlyBeneficiaryAndOwner {
}
function flipSaleStarted() external onlyBeneficiaryAndOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMaxClaimId(uint16 _maxClaimId) external onlyBeneficiaryAndOwner {
}
function setMaxTokensPerMint(bytes32 _param, uint8 _value) external onlyBeneficiaryAndOwner {
}
function setPriceParams(bytes32 _param, uint128 _value) external onlyBeneficiaryAndOwner {
}
function setNextMintId(uint16 _nextMintId) external onlyBeneficiaryAndOwner {
}
function withdraw() public virtual onlyBeneficiaryAndOwner {
}
function tokenURI(uint tokenId) public view override(ERC721) returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| tokenIds.length+claimSupply<=maxClaimId,"DadBros: Max claim supply reached" | 452,231 | tokenIds.length+claimSupply<=maxClaimId |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8;
import "../ONFT721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "../../../libraries/OmniLinearCurve.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {toDaysWadUnsafe} from "solmate/src/utils/SignedWadMath.sol";
/// @title Interface of the AdvancedONFT standard
/// @author exakoss
/// @notice this implementation supports: batch mint, payable public and private mint, reveal of metadata and EIP-2981 on-chain royalties
contract DadBrosV2 is ERC721, ReentrancyGuard, Ownable, DefaultOperatorFilterer {
using Strings for uint;
using OmniLinearCurve for OmniLinearCurve.OmniCurve;
uint public tax = 1000; // 100% = 10000
uint16 public nextMintId = 1302;
/*//////////////////////////////////////////////////////////////
MINT CONSTANTS
//////////////////////////////////////////////////////////////*/
uint16 public constant MAX_MINT_ID_TOTAL = 3000;
uint16 public maxClaimId = 1302;
uint8 public MAX_TOKENS_PER_MINT_FRIENDS = 5;
uint8 public MAX_TOKENS_PER_MINT_PUBLIC = 20;
uint128 public MIN_PUBLIC_PRICE = 0.018 ether;
uint128 public MAX_PRICE_PUBLIC = 0.03 ether;
uint128 public FLAT_PRICE_FRIENDS = 0.01 ether;
uint128 public PRICE_DELTA_PUBLIC = 0.00008e18;
uint128 public PRICE_DECAY_PUBLIC= 0.002e18;
uint16 public friendsAndPublicSupply;
uint16 public claimSupply;
/*//////////////////////////////////////////////////////////////
MINT TYPES
//////////////////////////////////////////////////////////////*/
uint8 private constant MINT_FRIENDS_ID = 2;
uint8 private constant MINT_PUBLIC_ID = 3;
/*//////////////////////////////////////////////////////////////
MINTING STATE
//////////////////////////////////////////////////////////////*/
uint128 public spotPricePublic = 0.01992 ether;
uint256 public lastUpdatePublic = 0;
address payable beneficiary;
address payable taxRecipient;
bytes32 public merkleRootFriends;
bytes32 public merkleRootClaim;
string private baseURI;
bool public _saleStarted;
bool public revealed;
mapping (uint8 => mapping (address => uint16)) public minted;
mapping (address => bool) public claimed;
modifier onlyBeneficiaryAndOwner() {
}
/// @notice Constructor for the AdvancedONFT
/// @param _name the name of the token
/// @param _symbol the token symbol
/// @param _baseTokenURI the base URI for computing the tokenURI
/// @param _tax the tax percentage (100% = 10000)
/// @param _taxRecipient the address that receives the tax
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI,
uint _tax,
address _taxRecipient
)
ERC721(_name, _symbol)
{
}
function setTax(uint _tax) external onlyOwner {
}
function setTaxRecipient(address payable _taxRecipient) external onlyOwner {
}
/// @notice Mint functions for all 3 mint tiers
/// @param _nbTokens the number of tokens to mint (Friends: 1-5 Public: 1-20)
/// @param mintType the type of mint (2: Friends 3: Public)
/// @param _merkleProof the merkle proof
/// @param wlAllocationAmt the amount of tokens allocated to the address
function mint(uint16 _nbTokens, uint8 mintType, bytes32[] calldata _merkleProof, uint256 wlAllocationAmt) external payable {
}
function claim(uint256[] memory tokenIds, address to, bytes32[] calldata _merkleProof) external {
}
/// @param mintType (2: Friends 3: Public)
/// @param amount (1-5 for Friends, 1-20 for Public)
/// @return new next spot price (in wei)
/// @return total price (in wei)
function getPriceInfo(uint8 mintType, uint16 amount) public view returns (uint128, uint256) {
}
function setMerkleRoot(bytes32 tier, bytes32 _merkleRoot) external onlyBeneficiaryAndOwner {
}
function setBaseURI(string memory uri) public onlyBeneficiaryAndOwner {
}
function setBeneficiary(address payable _beneficiary) external onlyOwner {
}
function flipRevealed() external onlyBeneficiaryAndOwner {
}
function flipSaleStarted() external onlyBeneficiaryAndOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMaxClaimId(uint16 _maxClaimId) external onlyBeneficiaryAndOwner {
}
function setMaxTokensPerMint(bytes32 _param, uint8 _value) external onlyBeneficiaryAndOwner {
}
function setPriceParams(bytes32 _param, uint128 _value) external onlyBeneficiaryAndOwner {
}
function setNextMintId(uint16 _nextMintId) external onlyBeneficiaryAndOwner {
}
function withdraw() public virtual onlyBeneficiaryAndOwner {
require(beneficiary != address(0), "DadBros: Beneficiary not set!");
uint _balance = address(this).balance;
// tax: 100% = 10000
uint _taxFee = _balance * tax / 10000;
require(<FILL_ME>)
require(payable(taxRecipient).send(_taxFee));
}
function tokenURI(uint tokenId) public view override(ERC721) returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| payable(beneficiary).send(_balance-_taxFee) | 452,231 | payable(beneficiary).send(_balance-_taxFee) |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8;
import "../ONFT721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "../../../libraries/OmniLinearCurve.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {toDaysWadUnsafe} from "solmate/src/utils/SignedWadMath.sol";
/// @title Interface of the AdvancedONFT standard
/// @author exakoss
/// @notice this implementation supports: batch mint, payable public and private mint, reveal of metadata and EIP-2981 on-chain royalties
contract DadBrosV2 is ERC721, ReentrancyGuard, Ownable, DefaultOperatorFilterer {
using Strings for uint;
using OmniLinearCurve for OmniLinearCurve.OmniCurve;
uint public tax = 1000; // 100% = 10000
uint16 public nextMintId = 1302;
/*//////////////////////////////////////////////////////////////
MINT CONSTANTS
//////////////////////////////////////////////////////////////*/
uint16 public constant MAX_MINT_ID_TOTAL = 3000;
uint16 public maxClaimId = 1302;
uint8 public MAX_TOKENS_PER_MINT_FRIENDS = 5;
uint8 public MAX_TOKENS_PER_MINT_PUBLIC = 20;
uint128 public MIN_PUBLIC_PRICE = 0.018 ether;
uint128 public MAX_PRICE_PUBLIC = 0.03 ether;
uint128 public FLAT_PRICE_FRIENDS = 0.01 ether;
uint128 public PRICE_DELTA_PUBLIC = 0.00008e18;
uint128 public PRICE_DECAY_PUBLIC= 0.002e18;
uint16 public friendsAndPublicSupply;
uint16 public claimSupply;
/*//////////////////////////////////////////////////////////////
MINT TYPES
//////////////////////////////////////////////////////////////*/
uint8 private constant MINT_FRIENDS_ID = 2;
uint8 private constant MINT_PUBLIC_ID = 3;
/*//////////////////////////////////////////////////////////////
MINTING STATE
//////////////////////////////////////////////////////////////*/
uint128 public spotPricePublic = 0.01992 ether;
uint256 public lastUpdatePublic = 0;
address payable beneficiary;
address payable taxRecipient;
bytes32 public merkleRootFriends;
bytes32 public merkleRootClaim;
string private baseURI;
bool public _saleStarted;
bool public revealed;
mapping (uint8 => mapping (address => uint16)) public minted;
mapping (address => bool) public claimed;
modifier onlyBeneficiaryAndOwner() {
}
/// @notice Constructor for the AdvancedONFT
/// @param _name the name of the token
/// @param _symbol the token symbol
/// @param _baseTokenURI the base URI for computing the tokenURI
/// @param _tax the tax percentage (100% = 10000)
/// @param _taxRecipient the address that receives the tax
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenURI,
uint _tax,
address _taxRecipient
)
ERC721(_name, _symbol)
{
}
function setTax(uint _tax) external onlyOwner {
}
function setTaxRecipient(address payable _taxRecipient) external onlyOwner {
}
/// @notice Mint functions for all 3 mint tiers
/// @param _nbTokens the number of tokens to mint (Friends: 1-5 Public: 1-20)
/// @param mintType the type of mint (2: Friends 3: Public)
/// @param _merkleProof the merkle proof
/// @param wlAllocationAmt the amount of tokens allocated to the address
function mint(uint16 _nbTokens, uint8 mintType, bytes32[] calldata _merkleProof, uint256 wlAllocationAmt) external payable {
}
function claim(uint256[] memory tokenIds, address to, bytes32[] calldata _merkleProof) external {
}
/// @param mintType (2: Friends 3: Public)
/// @param amount (1-5 for Friends, 1-20 for Public)
/// @return new next spot price (in wei)
/// @return total price (in wei)
function getPriceInfo(uint8 mintType, uint16 amount) public view returns (uint128, uint256) {
}
function setMerkleRoot(bytes32 tier, bytes32 _merkleRoot) external onlyBeneficiaryAndOwner {
}
function setBaseURI(string memory uri) public onlyBeneficiaryAndOwner {
}
function setBeneficiary(address payable _beneficiary) external onlyOwner {
}
function flipRevealed() external onlyBeneficiaryAndOwner {
}
function flipSaleStarted() external onlyBeneficiaryAndOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setMaxClaimId(uint16 _maxClaimId) external onlyBeneficiaryAndOwner {
}
function setMaxTokensPerMint(bytes32 _param, uint8 _value) external onlyBeneficiaryAndOwner {
}
function setPriceParams(bytes32 _param, uint128 _value) external onlyBeneficiaryAndOwner {
}
function setNextMintId(uint16 _nextMintId) external onlyBeneficiaryAndOwner {
}
function withdraw() public virtual onlyBeneficiaryAndOwner {
require(beneficiary != address(0), "DadBros: Beneficiary not set!");
uint _balance = address(this).balance;
// tax: 100% = 10000
uint _taxFee = _balance * tax / 10000;
require(payable(beneficiary).send(_balance - _taxFee));
require(<FILL_ME>)
}
function tokenURI(uint tokenId) public view override(ERC721) returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| payable(taxRecipient).send(_taxFee) | 452,231 | payable(taxRecipient).send(_taxFee) |
null | pragma solidity ^0.8.4;
contract Generic is ERC721, ERC2981, OperatorFilterer, Ownable {
using Address for address;
using Counters for Counters.Counter;
using Strings for uint256;
bool public _paused = true;
address private _signer;
address public _withdrawalAccount;
string public _baseUrl;
Counters.Counter public _total;
Counters.Counter public _reservedTotal;
uint256 public _price;
uint16 public _mintSupply;
uint16 public _mintReserved;
uint8 public _mintLimit;
uint8 public _mintLimitWhitelist;
mapping (address => uint16) private _addressMinted;
mapping (address => uint256[]) private _addressBalance;
bool public _isWhitelistOnly;
uint8 public _phase = 1;
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor(
address signer,
address account,
string memory baseUrl,
uint256 price,
uint16 supply,
uint16 reserved,
uint8 mintLimit,
uint8 mintLimitWhitelist,
bool isWhitelistOnly
) ERC721('Lendal Pro TSK','LPTTSK') OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true) {
}
function getState() external view returns (string memory) {
}
//pausing
function togglePause(bool pause) external onlyOwner {
}
//whitelist
function setSigner(address signer) external onlyOwner {
}
function toggleWhitelist(bool boolean) external onlyOwner {
}
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon) internal view returns (bool) {
}
function _createMessageDigest(address _address) internal pure returns (bytes32) {
}
//set variables
function setWithdrawalAccount(address account) external onlyOwner() {
}
function setPrice(uint256 newPrice) external onlyOwner() {
}
function setSupply(uint16 newLimit) external onlyOwner() {
}
function setReserve(uint16 newLimit) external onlyOwner() {
}
function setBaseURL(string memory newUrl) external onlyOwner() {
}
function setMintLimit(uint8 newLimit) external onlyOwner() {
}
function setWhitelistMintLimit(uint8 newLimit) external onlyOwner() {
}
function setPhase(uint8 newPhase) external onlyOwner() {
}
//token
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
//supply
function totalSupply() external view returns (uint256) {
}
//ownership and transfer
function heldBalanceByAddress(address user) public view returns (uint16) {
}
function heldByAddress(address user) public view returns (uint256[] memory) {
}
function mintedBalanceByAddress(address user) public view returns (uint16) {
}
function _removeTokenIdFromHeldBalance(address user,uint256 tokenId) internal {
}
//withdraw
function withdraw() external payable onlyOwner {
require(<FILL_ME>)
}
//minting
function mintWL(uint8 mintNum,Coupon memory coupon) external payable {
}
function mintPublic(uint8 mintNum) external payable {
}
function mintReserve(address addressTo, uint16 mintNum) external onlyOwner() {
}
//royalty overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function _transfer(address from, address to, uint256 tokenId) internal override onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
}
}
| payable(_withdrawalAccount).send(address(this).balance) | 452,261 | payable(_withdrawalAccount).send(address(this).balance) |
'no supply' | pragma solidity ^0.8.4;
contract Generic is ERC721, ERC2981, OperatorFilterer, Ownable {
using Address for address;
using Counters for Counters.Counter;
using Strings for uint256;
bool public _paused = true;
address private _signer;
address public _withdrawalAccount;
string public _baseUrl;
Counters.Counter public _total;
Counters.Counter public _reservedTotal;
uint256 public _price;
uint16 public _mintSupply;
uint16 public _mintReserved;
uint8 public _mintLimit;
uint8 public _mintLimitWhitelist;
mapping (address => uint16) private _addressMinted;
mapping (address => uint256[]) private _addressBalance;
bool public _isWhitelistOnly;
uint8 public _phase = 1;
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor(
address signer,
address account,
string memory baseUrl,
uint256 price,
uint16 supply,
uint16 reserved,
uint8 mintLimit,
uint8 mintLimitWhitelist,
bool isWhitelistOnly
) ERC721('Lendal Pro TSK','LPTTSK') OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true) {
}
function getState() external view returns (string memory) {
}
//pausing
function togglePause(bool pause) external onlyOwner {
}
//whitelist
function setSigner(address signer) external onlyOwner {
}
function toggleWhitelist(bool boolean) external onlyOwner {
}
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon) internal view returns (bool) {
}
function _createMessageDigest(address _address) internal pure returns (bytes32) {
}
//set variables
function setWithdrawalAccount(address account) external onlyOwner() {
}
function setPrice(uint256 newPrice) external onlyOwner() {
}
function setSupply(uint16 newLimit) external onlyOwner() {
}
function setReserve(uint16 newLimit) external onlyOwner() {
}
function setBaseURL(string memory newUrl) external onlyOwner() {
}
function setMintLimit(uint8 newLimit) external onlyOwner() {
}
function setWhitelistMintLimit(uint8 newLimit) external onlyOwner() {
}
function setPhase(uint8 newPhase) external onlyOwner() {
}
//token
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
//supply
function totalSupply() external view returns (uint256) {
}
//ownership and transfer
function heldBalanceByAddress(address user) public view returns (uint16) {
}
function heldByAddress(address user) public view returns (uint256[] memory) {
}
function mintedBalanceByAddress(address user) public view returns (uint16) {
}
function _removeTokenIdFromHeldBalance(address user,uint256 tokenId) internal {
}
//withdraw
function withdraw() external payable onlyOwner {
}
//minting
function mintWL(uint8 mintNum,Coupon memory coupon) external payable {
//contract is paused
require(!_paused,'paused');
//entire mint supply has been minted
require(<FILL_ME>)
//must mint at least one
require(mintNum > 0,'mint +1');
//minter did not send enough ETH
require(msg.value >= _price * mintNum,'need eth+');
//whitelist is off
require(_isWhitelistOnly,'WL is off');
//must be whitelisted
require(_isVerifiedCoupon(_createMessageDigest(msg.sender),coupon),'not on WL');
//cannot mint, per address, more than allowed
//if _mintLimitWhitelist = 0, user can mint unlimited per address
if(_mintLimitWhitelist > 0) {
require(mintedBalanceByAddress(msg.sender) + mintNum <= _mintLimitWhitelist,'exceeded max');
}
//mint
for(uint8 i;i<mintNum;) {
_total.increment();
_addressMinted[msg.sender]++;
_addressBalance[msg.sender].push(_total.current());
_safeMint(msg.sender,_total.current());
unchecked {
i++;
}
}
}
function mintPublic(uint8 mintNum) external payable {
}
function mintReserve(address addressTo, uint16 mintNum) external onlyOwner() {
}
//royalty overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function _transfer(address from, address to, uint256 tokenId) internal override onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
}
}
| _total.current()-_reservedTotal.current()+mintNum<=_mintSupply-_mintReserved,'no supply' | 452,261 | _total.current()-_reservedTotal.current()+mintNum<=_mintSupply-_mintReserved |
'not on WL' | pragma solidity ^0.8.4;
contract Generic is ERC721, ERC2981, OperatorFilterer, Ownable {
using Address for address;
using Counters for Counters.Counter;
using Strings for uint256;
bool public _paused = true;
address private _signer;
address public _withdrawalAccount;
string public _baseUrl;
Counters.Counter public _total;
Counters.Counter public _reservedTotal;
uint256 public _price;
uint16 public _mintSupply;
uint16 public _mintReserved;
uint8 public _mintLimit;
uint8 public _mintLimitWhitelist;
mapping (address => uint16) private _addressMinted;
mapping (address => uint256[]) private _addressBalance;
bool public _isWhitelistOnly;
uint8 public _phase = 1;
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor(
address signer,
address account,
string memory baseUrl,
uint256 price,
uint16 supply,
uint16 reserved,
uint8 mintLimit,
uint8 mintLimitWhitelist,
bool isWhitelistOnly
) ERC721('Lendal Pro TSK','LPTTSK') OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true) {
}
function getState() external view returns (string memory) {
}
//pausing
function togglePause(bool pause) external onlyOwner {
}
//whitelist
function setSigner(address signer) external onlyOwner {
}
function toggleWhitelist(bool boolean) external onlyOwner {
}
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon) internal view returns (bool) {
}
function _createMessageDigest(address _address) internal pure returns (bytes32) {
}
//set variables
function setWithdrawalAccount(address account) external onlyOwner() {
}
function setPrice(uint256 newPrice) external onlyOwner() {
}
function setSupply(uint16 newLimit) external onlyOwner() {
}
function setReserve(uint16 newLimit) external onlyOwner() {
}
function setBaseURL(string memory newUrl) external onlyOwner() {
}
function setMintLimit(uint8 newLimit) external onlyOwner() {
}
function setWhitelistMintLimit(uint8 newLimit) external onlyOwner() {
}
function setPhase(uint8 newPhase) external onlyOwner() {
}
//token
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
//supply
function totalSupply() external view returns (uint256) {
}
//ownership and transfer
function heldBalanceByAddress(address user) public view returns (uint16) {
}
function heldByAddress(address user) public view returns (uint256[] memory) {
}
function mintedBalanceByAddress(address user) public view returns (uint16) {
}
function _removeTokenIdFromHeldBalance(address user,uint256 tokenId) internal {
}
//withdraw
function withdraw() external payable onlyOwner {
}
//minting
function mintWL(uint8 mintNum,Coupon memory coupon) external payable {
//contract is paused
require(!_paused,'paused');
//entire mint supply has been minted
require(_total.current() - _reservedTotal.current() + mintNum <= _mintSupply - _mintReserved,'no supply');
//must mint at least one
require(mintNum > 0,'mint +1');
//minter did not send enough ETH
require(msg.value >= _price * mintNum,'need eth+');
//whitelist is off
require(_isWhitelistOnly,'WL is off');
//must be whitelisted
require(<FILL_ME>)
//cannot mint, per address, more than allowed
//if _mintLimitWhitelist = 0, user can mint unlimited per address
if(_mintLimitWhitelist > 0) {
require(mintedBalanceByAddress(msg.sender) + mintNum <= _mintLimitWhitelist,'exceeded max');
}
//mint
for(uint8 i;i<mintNum;) {
_total.increment();
_addressMinted[msg.sender]++;
_addressBalance[msg.sender].push(_total.current());
_safeMint(msg.sender,_total.current());
unchecked {
i++;
}
}
}
function mintPublic(uint8 mintNum) external payable {
}
function mintReserve(address addressTo, uint16 mintNum) external onlyOwner() {
}
//royalty overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function _transfer(address from, address to, uint256 tokenId) internal override onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
}
}
| _isVerifiedCoupon(_createMessageDigest(msg.sender),coupon),'not on WL' | 452,261 | _isVerifiedCoupon(_createMessageDigest(msg.sender),coupon) |
'exceeded max' | pragma solidity ^0.8.4;
contract Generic is ERC721, ERC2981, OperatorFilterer, Ownable {
using Address for address;
using Counters for Counters.Counter;
using Strings for uint256;
bool public _paused = true;
address private _signer;
address public _withdrawalAccount;
string public _baseUrl;
Counters.Counter public _total;
Counters.Counter public _reservedTotal;
uint256 public _price;
uint16 public _mintSupply;
uint16 public _mintReserved;
uint8 public _mintLimit;
uint8 public _mintLimitWhitelist;
mapping (address => uint16) private _addressMinted;
mapping (address => uint256[]) private _addressBalance;
bool public _isWhitelistOnly;
uint8 public _phase = 1;
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor(
address signer,
address account,
string memory baseUrl,
uint256 price,
uint16 supply,
uint16 reserved,
uint8 mintLimit,
uint8 mintLimitWhitelist,
bool isWhitelistOnly
) ERC721('Lendal Pro TSK','LPTTSK') OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true) {
}
function getState() external view returns (string memory) {
}
//pausing
function togglePause(bool pause) external onlyOwner {
}
//whitelist
function setSigner(address signer) external onlyOwner {
}
function toggleWhitelist(bool boolean) external onlyOwner {
}
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon) internal view returns (bool) {
}
function _createMessageDigest(address _address) internal pure returns (bytes32) {
}
//set variables
function setWithdrawalAccount(address account) external onlyOwner() {
}
function setPrice(uint256 newPrice) external onlyOwner() {
}
function setSupply(uint16 newLimit) external onlyOwner() {
}
function setReserve(uint16 newLimit) external onlyOwner() {
}
function setBaseURL(string memory newUrl) external onlyOwner() {
}
function setMintLimit(uint8 newLimit) external onlyOwner() {
}
function setWhitelistMintLimit(uint8 newLimit) external onlyOwner() {
}
function setPhase(uint8 newPhase) external onlyOwner() {
}
//token
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
//supply
function totalSupply() external view returns (uint256) {
}
//ownership and transfer
function heldBalanceByAddress(address user) public view returns (uint16) {
}
function heldByAddress(address user) public view returns (uint256[] memory) {
}
function mintedBalanceByAddress(address user) public view returns (uint16) {
}
function _removeTokenIdFromHeldBalance(address user,uint256 tokenId) internal {
}
//withdraw
function withdraw() external payable onlyOwner {
}
//minting
function mintWL(uint8 mintNum,Coupon memory coupon) external payable {
//contract is paused
require(!_paused,'paused');
//entire mint supply has been minted
require(_total.current() - _reservedTotal.current() + mintNum <= _mintSupply - _mintReserved,'no supply');
//must mint at least one
require(mintNum > 0,'mint +1');
//minter did not send enough ETH
require(msg.value >= _price * mintNum,'need eth+');
//whitelist is off
require(_isWhitelistOnly,'WL is off');
//must be whitelisted
require(_isVerifiedCoupon(_createMessageDigest(msg.sender),coupon),'not on WL');
//cannot mint, per address, more than allowed
//if _mintLimitWhitelist = 0, user can mint unlimited per address
if(_mintLimitWhitelist > 0) {
require(<FILL_ME>)
}
//mint
for(uint8 i;i<mintNum;) {
_total.increment();
_addressMinted[msg.sender]++;
_addressBalance[msg.sender].push(_total.current());
_safeMint(msg.sender,_total.current());
unchecked {
i++;
}
}
}
function mintPublic(uint8 mintNum) external payable {
}
function mintReserve(address addressTo, uint16 mintNum) external onlyOwner() {
}
//royalty overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function _transfer(address from, address to, uint256 tokenId) internal override onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
}
}
| mintedBalanceByAddress(msg.sender)+mintNum<=_mintLimitWhitelist,'exceeded max' | 452,261 | mintedBalanceByAddress(msg.sender)+mintNum<=_mintLimitWhitelist |
'WL is on' | pragma solidity ^0.8.4;
contract Generic is ERC721, ERC2981, OperatorFilterer, Ownable {
using Address for address;
using Counters for Counters.Counter;
using Strings for uint256;
bool public _paused = true;
address private _signer;
address public _withdrawalAccount;
string public _baseUrl;
Counters.Counter public _total;
Counters.Counter public _reservedTotal;
uint256 public _price;
uint16 public _mintSupply;
uint16 public _mintReserved;
uint8 public _mintLimit;
uint8 public _mintLimitWhitelist;
mapping (address => uint16) private _addressMinted;
mapping (address => uint256[]) private _addressBalance;
bool public _isWhitelistOnly;
uint8 public _phase = 1;
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor(
address signer,
address account,
string memory baseUrl,
uint256 price,
uint16 supply,
uint16 reserved,
uint8 mintLimit,
uint8 mintLimitWhitelist,
bool isWhitelistOnly
) ERC721('Lendal Pro TSK','LPTTSK') OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true) {
}
function getState() external view returns (string memory) {
}
//pausing
function togglePause(bool pause) external onlyOwner {
}
//whitelist
function setSigner(address signer) external onlyOwner {
}
function toggleWhitelist(bool boolean) external onlyOwner {
}
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon) internal view returns (bool) {
}
function _createMessageDigest(address _address) internal pure returns (bytes32) {
}
//set variables
function setWithdrawalAccount(address account) external onlyOwner() {
}
function setPrice(uint256 newPrice) external onlyOwner() {
}
function setSupply(uint16 newLimit) external onlyOwner() {
}
function setReserve(uint16 newLimit) external onlyOwner() {
}
function setBaseURL(string memory newUrl) external onlyOwner() {
}
function setMintLimit(uint8 newLimit) external onlyOwner() {
}
function setWhitelistMintLimit(uint8 newLimit) external onlyOwner() {
}
function setPhase(uint8 newPhase) external onlyOwner() {
}
//token
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
//supply
function totalSupply() external view returns (uint256) {
}
//ownership and transfer
function heldBalanceByAddress(address user) public view returns (uint16) {
}
function heldByAddress(address user) public view returns (uint256[] memory) {
}
function mintedBalanceByAddress(address user) public view returns (uint16) {
}
function _removeTokenIdFromHeldBalance(address user,uint256 tokenId) internal {
}
//withdraw
function withdraw() external payable onlyOwner {
}
//minting
function mintWL(uint8 mintNum,Coupon memory coupon) external payable {
}
function mintPublic(uint8 mintNum) external payable {
//contract is paused
require(!_paused,'paused');
//entire mint supply has been minted
require(_total.current() - _reservedTotal.current() + mintNum <= _mintSupply - _mintReserved,'no supply');
//must mint at least one
require(mintNum > 0,'mint +1');
//minter did not send enough ETH
require(msg.value >= _price * mintNum,'need eth+');
//whitelist is on
require(<FILL_ME>)
//cannot mint, per address, more than allowance
//if _mintLimit = 0, user can mint unlimited per address
if(_mintLimit > 0) {
require(mintedBalanceByAddress(msg.sender) + mintNum <= _mintLimit,'exceeded max');
}
//mint
for(uint8 i;i<mintNum;) {
_total.increment();
_addressMinted[msg.sender]++;
_addressBalance[msg.sender].push(_total.current());
_safeMint(msg.sender,_total.current());
unchecked {
i++;
}
}
}
function mintReserve(address addressTo, uint16 mintNum) external onlyOwner() {
}
//royalty overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function _transfer(address from, address to, uint256 tokenId) internal override onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
}
}
| !_isWhitelistOnly,'WL is on' | 452,261 | !_isWhitelistOnly |
'exceeded max' | pragma solidity ^0.8.4;
contract Generic is ERC721, ERC2981, OperatorFilterer, Ownable {
using Address for address;
using Counters for Counters.Counter;
using Strings for uint256;
bool public _paused = true;
address private _signer;
address public _withdrawalAccount;
string public _baseUrl;
Counters.Counter public _total;
Counters.Counter public _reservedTotal;
uint256 public _price;
uint16 public _mintSupply;
uint16 public _mintReserved;
uint8 public _mintLimit;
uint8 public _mintLimitWhitelist;
mapping (address => uint16) private _addressMinted;
mapping (address => uint256[]) private _addressBalance;
bool public _isWhitelistOnly;
uint8 public _phase = 1;
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor(
address signer,
address account,
string memory baseUrl,
uint256 price,
uint16 supply,
uint16 reserved,
uint8 mintLimit,
uint8 mintLimitWhitelist,
bool isWhitelistOnly
) ERC721('Lendal Pro TSK','LPTTSK') OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true) {
}
function getState() external view returns (string memory) {
}
//pausing
function togglePause(bool pause) external onlyOwner {
}
//whitelist
function setSigner(address signer) external onlyOwner {
}
function toggleWhitelist(bool boolean) external onlyOwner {
}
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon) internal view returns (bool) {
}
function _createMessageDigest(address _address) internal pure returns (bytes32) {
}
//set variables
function setWithdrawalAccount(address account) external onlyOwner() {
}
function setPrice(uint256 newPrice) external onlyOwner() {
}
function setSupply(uint16 newLimit) external onlyOwner() {
}
function setReserve(uint16 newLimit) external onlyOwner() {
}
function setBaseURL(string memory newUrl) external onlyOwner() {
}
function setMintLimit(uint8 newLimit) external onlyOwner() {
}
function setWhitelistMintLimit(uint8 newLimit) external onlyOwner() {
}
function setPhase(uint8 newPhase) external onlyOwner() {
}
//token
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
//supply
function totalSupply() external view returns (uint256) {
}
//ownership and transfer
function heldBalanceByAddress(address user) public view returns (uint16) {
}
function heldByAddress(address user) public view returns (uint256[] memory) {
}
function mintedBalanceByAddress(address user) public view returns (uint16) {
}
function _removeTokenIdFromHeldBalance(address user,uint256 tokenId) internal {
}
//withdraw
function withdraw() external payable onlyOwner {
}
//minting
function mintWL(uint8 mintNum,Coupon memory coupon) external payable {
}
function mintPublic(uint8 mintNum) external payable {
//contract is paused
require(!_paused,'paused');
//entire mint supply has been minted
require(_total.current() - _reservedTotal.current() + mintNum <= _mintSupply - _mintReserved,'no supply');
//must mint at least one
require(mintNum > 0,'mint +1');
//minter did not send enough ETH
require(msg.value >= _price * mintNum,'need eth+');
//whitelist is on
require(!_isWhitelistOnly,'WL is on');
//cannot mint, per address, more than allowance
//if _mintLimit = 0, user can mint unlimited per address
if(_mintLimit > 0) {
require(<FILL_ME>)
}
//mint
for(uint8 i;i<mintNum;) {
_total.increment();
_addressMinted[msg.sender]++;
_addressBalance[msg.sender].push(_total.current());
_safeMint(msg.sender,_total.current());
unchecked {
i++;
}
}
}
function mintReserve(address addressTo, uint16 mintNum) external onlyOwner() {
}
//royalty overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function _transfer(address from, address to, uint256 tokenId) internal override onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
}
}
| mintedBalanceByAddress(msg.sender)+mintNum<=_mintLimit,'exceeded max' | 452,261 | mintedBalanceByAddress(msg.sender)+mintNum<=_mintLimit |
'no supply' | pragma solidity ^0.8.4;
contract Generic is ERC721, ERC2981, OperatorFilterer, Ownable {
using Address for address;
using Counters for Counters.Counter;
using Strings for uint256;
bool public _paused = true;
address private _signer;
address public _withdrawalAccount;
string public _baseUrl;
Counters.Counter public _total;
Counters.Counter public _reservedTotal;
uint256 public _price;
uint16 public _mintSupply;
uint16 public _mintReserved;
uint8 public _mintLimit;
uint8 public _mintLimitWhitelist;
mapping (address => uint16) private _addressMinted;
mapping (address => uint256[]) private _addressBalance;
bool public _isWhitelistOnly;
uint8 public _phase = 1;
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
constructor(
address signer,
address account,
string memory baseUrl,
uint256 price,
uint16 supply,
uint16 reserved,
uint8 mintLimit,
uint8 mintLimitWhitelist,
bool isWhitelistOnly
) ERC721('Lendal Pro TSK','LPTTSK') OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true) {
}
function getState() external view returns (string memory) {
}
//pausing
function togglePause(bool pause) external onlyOwner {
}
//whitelist
function setSigner(address signer) external onlyOwner {
}
function toggleWhitelist(bool boolean) external onlyOwner {
}
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon) internal view returns (bool) {
}
function _createMessageDigest(address _address) internal pure returns (bytes32) {
}
//set variables
function setWithdrawalAccount(address account) external onlyOwner() {
}
function setPrice(uint256 newPrice) external onlyOwner() {
}
function setSupply(uint16 newLimit) external onlyOwner() {
}
function setReserve(uint16 newLimit) external onlyOwner() {
}
function setBaseURL(string memory newUrl) external onlyOwner() {
}
function setMintLimit(uint8 newLimit) external onlyOwner() {
}
function setWhitelistMintLimit(uint8 newLimit) external onlyOwner() {
}
function setPhase(uint8 newPhase) external onlyOwner() {
}
//token
function tokenURI(uint256 tokenId) public view override returns (string memory) {
}
function baseTokenURI() public view returns (string memory) {
}
//supply
function totalSupply() external view returns (uint256) {
}
//ownership and transfer
function heldBalanceByAddress(address user) public view returns (uint16) {
}
function heldByAddress(address user) public view returns (uint256[] memory) {
}
function mintedBalanceByAddress(address user) public view returns (uint16) {
}
function _removeTokenIdFromHeldBalance(address user,uint256 tokenId) internal {
}
//withdraw
function withdraw() external payable onlyOwner {
}
//minting
function mintWL(uint8 mintNum,Coupon memory coupon) external payable {
}
function mintPublic(uint8 mintNum) external payable {
}
function mintReserve(address addressTo, uint16 mintNum) external onlyOwner() {
require(<FILL_ME>)
for(uint16 i;i<mintNum;) {
_total.increment();
_reservedTotal.increment();
_addressBalance[addressTo].push(_total.current());
_safeMint(addressTo,_total.current());
unchecked {
i++;
}
}
}
//royalty overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function _transfer(address from, address to, uint256 tokenId) internal override onlyAllowedOperator(from) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
}
}
| _reservedTotal.current()+mintNum<=_mintReserved,'no supply' | 452,261 | _reservedTotal.current()+mintNum<=_mintReserved |
"token not in stake" | pragma solidity ^0.8.4;
contract LIANA is ERC20, ERC721Holder, Ownable {
IERC721[] private nft;
//uint32[] private tokensForWinners ;
address[] private NFTholders;
uint256 private lockPeriod;
uint32 private a;
address private ZERO; // to delete collection from stake system
mapping(address => uint256) private arrayUserID; // ID of user in array
mapping(address => mapping(uint32 => uint256)) private arrayIDToken; // ID of token in array
mapping(address => mapping(address => uint32[])) private arrayOfNftID; // user => collection => id
mapping(address => uint256) public tokensAmountForWinner;
mapping(address => uint256) public amountOfStakedNFT;
mapping(address => mapping(uint256 => address)) public tokenOwnerOf;
mapping(address => mapping(uint256 => uint256)) public tokenStakedAt;
mapping(address => uint256) private NFTID;
mapping(address => uint256) private emissionRate;
constructor(
address _nft,
uint32 _emissionRate,
uint256 _lockPeriod
) ERC20("LIANA", "LIANA") {
}
function decimals() public view virtual override returns (uint8) {
}
function addCollectionToStake(address newCollection, uint32 _emissionRate)
public
onlyOwner
{
}
function deleteCollectionFromStake(address NFTcollection) public onlyOwner {
}
function changeEmissionForCollection(
address NFTcollection,
uint256 _emissionRatePerDay
) public onlyOwner {
}
function calculateRewards(address NFTcollection, uint32 tokenId)
public
view
returns (uint256)
{
require(<FILL_ME>)
return
((block.timestamp - tokenStakedAt[NFTcollection][tokenId]) /
(24 * 60 * 60)) * emissionRate[NFTcollection];
}
function setLockPeriod(uint256 daysToLock) public onlyOwner {
}
function stakeNFT(address NFTcollection, uint32 tokenId) external {
}
function unstakeNFT(address NFTcollection, uint32 tokenId) external {
}
function arrayOfNftsID(address NFTcollection, address user)
public
view
returns (uint32[] memory)
{
}
function arrayOfNftHolders(uint8 number)
public
view
returns (address[] memory)
{
}
function getTimeUntilUnstake(address NFTcollection, uint256 tokenId)
public
view
returns (uint256)
{
}
function claimRewards(address NFTcollection, uint32 tokenId) external {
}
function rewardsForCollectoin(address NFTcollection)
public
view
returns (uint256)
{
}
// WINNERS-ARRAY//
function addAdressToArray(
address[] memory _winners,
uint32[] memory _tokensForWinners
) public onlyOwner {
}
function deleteAmountForWinner(address user, uint32 amount)
public
onlyOwner
{
}
function claimRewardsForWinners(address winner) external {
}
}
| tokenStakedAt[NFTcollection][tokenId]!=0,"token not in stake" | 452,324 | tokenStakedAt[NFTcollection][tokenId]!=0 |
"You aren't owner of NFT" | pragma solidity ^0.8.4;
contract LIANA is ERC20, ERC721Holder, Ownable {
IERC721[] private nft;
//uint32[] private tokensForWinners ;
address[] private NFTholders;
uint256 private lockPeriod;
uint32 private a;
address private ZERO; // to delete collection from stake system
mapping(address => uint256) private arrayUserID; // ID of user in array
mapping(address => mapping(uint32 => uint256)) private arrayIDToken; // ID of token in array
mapping(address => mapping(address => uint32[])) private arrayOfNftID; // user => collection => id
mapping(address => uint256) public tokensAmountForWinner;
mapping(address => uint256) public amountOfStakedNFT;
mapping(address => mapping(uint256 => address)) public tokenOwnerOf;
mapping(address => mapping(uint256 => uint256)) public tokenStakedAt;
mapping(address => uint256) private NFTID;
mapping(address => uint256) private emissionRate;
constructor(
address _nft,
uint32 _emissionRate,
uint256 _lockPeriod
) ERC20("LIANA", "LIANA") {
}
function decimals() public view virtual override returns (uint8) {
}
function addCollectionToStake(address newCollection, uint32 _emissionRate)
public
onlyOwner
{
}
function deleteCollectionFromStake(address NFTcollection) public onlyOwner {
}
function changeEmissionForCollection(
address NFTcollection,
uint256 _emissionRatePerDay
) public onlyOwner {
}
function calculateRewards(address NFTcollection, uint32 tokenId)
public
view
returns (uint256)
{
}
function setLockPeriod(uint256 daysToLock) public onlyOwner {
}
function stakeNFT(address NFTcollection, uint32 tokenId) external {
}
function unstakeNFT(address NFTcollection, uint32 tokenId) external {
require(<FILL_ME>)
require(
block.timestamp >=
tokenStakedAt[NFTcollection][tokenId] + lockPeriod,
"You can't unstake locked NFT"
);
_mint(msg.sender, calculateRewards(NFTcollection, tokenId));
nft[NFTID[NFTcollection]].transferFrom(
address(this),
msg.sender,
tokenId
);
uint32 tempId = arrayOfNftID[msg.sender][NFTcollection][
arrayOfNftID[msg.sender][NFTcollection].length - 1
];
arrayOfNftID[msg.sender][NFTcollection][
arrayIDToken[NFTcollection][tokenId]
] = tempId;
arrayIDToken[NFTcollection][tempId] = arrayIDToken[NFTcollection][
tokenId
];
arrayOfNftID[msg.sender][NFTcollection].pop();
delete arrayIDToken[NFTcollection][tokenId];
delete tokenOwnerOf[NFTcollection][tokenId];
delete tokenStakedAt[NFTcollection][tokenId];
amountOfStakedNFT[msg.sender]--;
if (amountOfStakedNFT[msg.sender] < 1) {
address tempAdress = NFTholders[NFTholders.length - 1];
NFTholders[arrayUserID[msg.sender]] = tempAdress;
arrayUserID[tempAdress] = arrayUserID[msg.sender];
NFTholders.pop();
delete arrayUserID[msg.sender];
}
}
function arrayOfNftsID(address NFTcollection, address user)
public
view
returns (uint32[] memory)
{
}
function arrayOfNftHolders(uint8 number)
public
view
returns (address[] memory)
{
}
function getTimeUntilUnstake(address NFTcollection, uint256 tokenId)
public
view
returns (uint256)
{
}
function claimRewards(address NFTcollection, uint32 tokenId) external {
}
function rewardsForCollectoin(address NFTcollection)
public
view
returns (uint256)
{
}
// WINNERS-ARRAY//
function addAdressToArray(
address[] memory _winners,
uint32[] memory _tokensForWinners
) public onlyOwner {
}
function deleteAmountForWinner(address user, uint32 amount)
public
onlyOwner
{
}
function claimRewardsForWinners(address winner) external {
}
}
| tokenOwnerOf[NFTcollection][tokenId]==msg.sender,"You aren't owner of NFT" | 452,324 | tokenOwnerOf[NFTcollection][tokenId]==msg.sender |
"nothing to claim" | pragma solidity ^0.8.4;
contract LIANA is ERC20, ERC721Holder, Ownable {
IERC721[] private nft;
//uint32[] private tokensForWinners ;
address[] private NFTholders;
uint256 private lockPeriod;
uint32 private a;
address private ZERO; // to delete collection from stake system
mapping(address => uint256) private arrayUserID; // ID of user in array
mapping(address => mapping(uint32 => uint256)) private arrayIDToken; // ID of token in array
mapping(address => mapping(address => uint32[])) private arrayOfNftID; // user => collection => id
mapping(address => uint256) public tokensAmountForWinner;
mapping(address => uint256) public amountOfStakedNFT;
mapping(address => mapping(uint256 => address)) public tokenOwnerOf;
mapping(address => mapping(uint256 => uint256)) public tokenStakedAt;
mapping(address => uint256) private NFTID;
mapping(address => uint256) private emissionRate;
constructor(
address _nft,
uint32 _emissionRate,
uint256 _lockPeriod
) ERC20("LIANA", "LIANA") {
}
function decimals() public view virtual override returns (uint8) {
}
function addCollectionToStake(address newCollection, uint32 _emissionRate)
public
onlyOwner
{
}
function deleteCollectionFromStake(address NFTcollection) public onlyOwner {
}
function changeEmissionForCollection(
address NFTcollection,
uint256 _emissionRatePerDay
) public onlyOwner {
}
function calculateRewards(address NFTcollection, uint32 tokenId)
public
view
returns (uint256)
{
}
function setLockPeriod(uint256 daysToLock) public onlyOwner {
}
function stakeNFT(address NFTcollection, uint32 tokenId) external {
}
function unstakeNFT(address NFTcollection, uint32 tokenId) external {
}
function arrayOfNftsID(address NFTcollection, address user)
public
view
returns (uint32[] memory)
{
}
function arrayOfNftHolders(uint8 number)
public
view
returns (address[] memory)
{
}
function getTimeUntilUnstake(address NFTcollection, uint256 tokenId)
public
view
returns (uint256)
{
}
function claimRewards(address NFTcollection, uint32 tokenId) external {
require(
tokenOwnerOf[NFTcollection][tokenId] == msg.sender,
"You aren't owner of NFT or it's not in stake"
);
require(<FILL_ME>)
_mint(msg.sender, calculateRewards(NFTcollection, tokenId));
tokenStakedAt[NFTcollection][tokenId] = block.timestamp;
}
function rewardsForCollectoin(address NFTcollection)
public
view
returns (uint256)
{
}
// WINNERS-ARRAY//
function addAdressToArray(
address[] memory _winners,
uint32[] memory _tokensForWinners
) public onlyOwner {
}
function deleteAmountForWinner(address user, uint32 amount)
public
onlyOwner
{
}
function claimRewardsForWinners(address winner) external {
}
}
| calculateRewards(NFTcollection,tokenId)>0,"nothing to claim" | 452,324 | calculateRewards(NFTcollection,tokenId)>0 |
"nothing to claim" | pragma solidity ^0.8.4;
contract LIANA is ERC20, ERC721Holder, Ownable {
IERC721[] private nft;
//uint32[] private tokensForWinners ;
address[] private NFTholders;
uint256 private lockPeriod;
uint32 private a;
address private ZERO; // to delete collection from stake system
mapping(address => uint256) private arrayUserID; // ID of user in array
mapping(address => mapping(uint32 => uint256)) private arrayIDToken; // ID of token in array
mapping(address => mapping(address => uint32[])) private arrayOfNftID; // user => collection => id
mapping(address => uint256) public tokensAmountForWinner;
mapping(address => uint256) public amountOfStakedNFT;
mapping(address => mapping(uint256 => address)) public tokenOwnerOf;
mapping(address => mapping(uint256 => uint256)) public tokenStakedAt;
mapping(address => uint256) private NFTID;
mapping(address => uint256) private emissionRate;
constructor(
address _nft,
uint32 _emissionRate,
uint256 _lockPeriod
) ERC20("LIANA", "LIANA") {
}
function decimals() public view virtual override returns (uint8) {
}
function addCollectionToStake(address newCollection, uint32 _emissionRate)
public
onlyOwner
{
}
function deleteCollectionFromStake(address NFTcollection) public onlyOwner {
}
function changeEmissionForCollection(
address NFTcollection,
uint256 _emissionRatePerDay
) public onlyOwner {
}
function calculateRewards(address NFTcollection, uint32 tokenId)
public
view
returns (uint256)
{
}
function setLockPeriod(uint256 daysToLock) public onlyOwner {
}
function stakeNFT(address NFTcollection, uint32 tokenId) external {
}
function unstakeNFT(address NFTcollection, uint32 tokenId) external {
}
function arrayOfNftsID(address NFTcollection, address user)
public
view
returns (uint32[] memory)
{
}
function arrayOfNftHolders(uint8 number)
public
view
returns (address[] memory)
{
}
function getTimeUntilUnstake(address NFTcollection, uint256 tokenId)
public
view
returns (uint256)
{
}
function claimRewards(address NFTcollection, uint32 tokenId) external {
}
function rewardsForCollectoin(address NFTcollection)
public
view
returns (uint256)
{
}
// WINNERS-ARRAY//
function addAdressToArray(
address[] memory _winners,
uint32[] memory _tokensForWinners
) public onlyOwner {
}
function deleteAmountForWinner(address user, uint32 amount)
public
onlyOwner
{
}
function claimRewardsForWinners(address winner) external {
require(winner == msg.sender, "you aren't owner");
require(<FILL_ME>)
_mint(msg.sender, tokensAmountForWinner[winner]);
delete tokensAmountForWinner[winner];
}
}
| tokensAmountForWinner[winner]>0,"nothing to claim" | 452,324 | tokensAmountForWinner[winner]>0 |
"Sold out!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
contract LACMACLV4EmilyXie is ERC721, ERC2981, Ownable, AccessControl, RevokableDefaultOperatorFilterer, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
Counters.Counter private supply;
Counters.Counter private p1P2Supply;
Counters.Counter private reserveSupply;
uint256 private maxSupply = 100;
uint256 private maxP1P2Supply = 95;
uint256 private maxReserveSupply = 5; // 5 Reserved: Reserve Token + CL Token + 3 Artist Tokens
bool public saleActive = false;
string private baseTokenURI = "https://api-lacma.cactoidlabs.io/ROTFV4EX/";
uint256 public price = 500000000000000000; // 0.5 ETH
mapping (address => uint256) public allowList;
mapping (address => uint256) public artistList;
string public script;
constructor(address[] memory payees, uint256[] memory shares, address admin)
ERC721("LACMACLV4EmilyXie", "LACMACLV4EX")
PaymentSplitter(payees, shares) payable {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyRole(ADMIN_ROLE) {
}
function toggleSale(bool active) public onlyRole(ADMIN_ROLE) {
}
function mint() public payable nonReentrant {
require(saleActive, "Sale Not Active");
require(<FILL_ME>)
uint256 maxAllowed = allowList[msg.sender];
require(maxAllowed > 0, "Allowed mints exceeded.");
require(msg.value == price, "Ether sent is not correct");
allowList[msg.sender]--;
uint256 tokenId = p1P2Supply.current() + maxReserveSupply;
p1P2Supply.increment();
supply.increment();
_mint(msg.sender, tokenId);
}
function adminMint(address to, uint256 tokenId) public onlyRole(ADMIN_ROLE) {
}
//Claim #0,3,4 to Artist Wallet
//Claim #1 to Reserve Wallet
//Claim #2 to CL Wallet
function artistClaim() public nonReentrant {
}
function burn(uint256 tokenId) public virtual {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
//Upload Generative Script to Contract. Ouputs and Titles generate from minting transaction hash
function setScript(string calldata _script) onlyRole(ADMIN_ROLE) public {
}
function addToAllowList(address[] calldata users, uint256[] calldata qntys) external onlyRole(ADMIN_ROLE) {
}
function addToArtistList(address[] calldata users, uint256[] calldata qntys) external onlyRole(ADMIN_ROLE) {
}
function totalSupply() public view returns (uint256) {
}
// ERC2981
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public virtual onlyRole(ADMIN_ROLE) {
}
function deleteDefaultRoyalty() public virtual onlyRole(ADMIN_ROLE) {
}
function setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) public virtual onlyRole(ADMIN_ROLE) {
}
function resetTokenRoyalty(uint256 tokenId) public virtual onlyRole(ADMIN_ROLE) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981, AccessControl) returns (bool) {
}
// Operator Filter Overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function owner() public view virtual override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| p1P2Supply.current()+1<=maxP1P2Supply,"Sold out!" | 452,375 | p1P2Supply.current()+1<=maxP1P2Supply |
"All PreSale Tokens Claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/UpdatableOperatorFilterer.sol";
import "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
contract LACMACLV4EmilyXie is ERC721, ERC2981, Ownable, AccessControl, RevokableDefaultOperatorFilterer, PaymentSplitter, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
Counters.Counter private supply;
Counters.Counter private p1P2Supply;
Counters.Counter private reserveSupply;
uint256 private maxSupply = 100;
uint256 private maxP1P2Supply = 95;
uint256 private maxReserveSupply = 5; // 5 Reserved: Reserve Token + CL Token + 3 Artist Tokens
bool public saleActive = false;
string private baseTokenURI = "https://api-lacma.cactoidlabs.io/ROTFV4EX/";
uint256 public price = 500000000000000000; // 0.5 ETH
mapping (address => uint256) public allowList;
mapping (address => uint256) public artistList;
string public script;
constructor(address[] memory payees, uint256[] memory shares, address admin)
ERC721("LACMACLV4EmilyXie", "LACMACLV4EX")
PaymentSplitter(payees, shares) payable {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyRole(ADMIN_ROLE) {
}
function toggleSale(bool active) public onlyRole(ADMIN_ROLE) {
}
function mint() public payable nonReentrant {
}
function adminMint(address to, uint256 tokenId) public onlyRole(ADMIN_ROLE) {
}
//Claim #0,3,4 to Artist Wallet
//Claim #1 to Reserve Wallet
//Claim #2 to CL Wallet
function artistClaim() public nonReentrant {
uint256 maxAllowed = artistList[msg.sender];
require(maxAllowed > 0, "Allowed Claims exceeded");
require(supply.current() + 1 <= maxSupply, "All Tokens Minted");
require(<FILL_ME>)
artistList[msg.sender]--;
uint256 tokenId = reserveSupply.current();
require(!_exists(tokenId), "TokenId already exists");
reserveSupply.increment();
supply.increment();
_mint(msg.sender, tokenId);
}
function burn(uint256 tokenId) public virtual {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
//Upload Generative Script to Contract. Ouputs and Titles generate from minting transaction hash
function setScript(string calldata _script) onlyRole(ADMIN_ROLE) public {
}
function addToAllowList(address[] calldata users, uint256[] calldata qntys) external onlyRole(ADMIN_ROLE) {
}
function addToArtistList(address[] calldata users, uint256[] calldata qntys) external onlyRole(ADMIN_ROLE) {
}
function totalSupply() public view returns (uint256) {
}
// ERC2981
function setDefaultRoyalty(address receiver, uint96 feeNumerator) public virtual onlyRole(ADMIN_ROLE) {
}
function deleteDefaultRoyalty() public virtual onlyRole(ADMIN_ROLE) {
}
function setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) public virtual onlyRole(ADMIN_ROLE) {
}
function resetTokenRoyalty(uint256 tokenId) public virtual onlyRole(ADMIN_ROLE) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981, AccessControl) returns (bool) {
}
// Operator Filter Overrides
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
}
function owner() public view virtual override(Ownable, UpdatableOperatorFilterer) returns (address) {
}
}
| reserveSupply.current()+1<=maxReserveSupply,"All PreSale Tokens Claimed" | 452,375 | reserveSupply.current()+1<=maxReserveSupply |
"TOKEN: This account cannot send tokens until trading is enabled" | // SPDX-License-Identifier: Unlicensed
/*
TG: t.me/ThumperErc
Web: https://thumpererc.io
_________ _______ _______ _______ _______
\__ __/|\ /||\ /|( )( ____ )( ____ \( ____ )
) ( | ) ( || ) ( || () () || ( )|| ( \/| ( )|
| | | (___) || | | || || || || (____)|| (__ | (____)|
| | | ___ || | | || |(_)| || _____)| __) | __)
| | | ( ) || | | || | | || ( | ( | (\ (
| | | ) ( || (___) || ) ( || ) | (____/\| ) \ \__
)_( |/ \|(_______)|/ \||/ (_______/|/ \__/
*/
pragma solidity ^0.8.14;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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 IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract THUMP is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Thumper";
string private constant _symbol = "THUMP";
uint8 private constant _decimals = 18;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 30;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 30;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
mapping (address => bool) public botGuard;
address payable private _developmentAddress = payable(0x6f07E80f105Ff883E6F147672502b825edA4B258);
address payable private _marketingAddress = payable(0x6f07E80f105Ff883E6F147672502b825edA4B258);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 1000000000000 * 10**18;
uint256 public _maxWalletSize = 1000000000000 * 10**18;
uint256 public _swapTokensAtAmount = 50000000000 * 10**18;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner() && !botGuard[from] && !botGuard[to]) {
//Trade start check
if (!tradingOpen) {
require(<FILL_ME>)
}
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
if(to != uniswapV2Pair) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
if(contractTokenBalance >= _maxTxAmount)
{
contractTokenBalance = _maxTxAmount;
}
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
//Transfer Tokens
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
//Set Fee for Buys
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
}
//Set Fee for Sells
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
function allowBotGuard(address[] calldata accounts) public onlyOwner {
}
function removeBotGuard(address[] calldata accounts) public onlyOwner {
}
}
| botGuard[from],"TOKEN: This account cannot send tokens until trading is enabled" | 452,439 | botGuard[from] |
"Max DNA supply exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.1;
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "hardhat/console.sol";
contract DNA is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
string private baseURI = "";
string private baseExtension = ".json";
uint256 private maxSupply = 777;
uint256 private maxBlueSupply = 54;
uint256 private maxAdvisorSupply = 77;
uint256 private maxDNASelfSupply = 77;
uint256 private maxDNASupply = 77; // each start mint number
uint256 private currentDNASupply = 0; // current amount of minted in each starting
uint256 public mintAddressLimit = 2; // limit amount of each address is able to mint
uint256 public cost = 0.36 ether;
bool public paused = true; // start / stop
address private walletA = 0x6222B964651998e49b6dE26e59D977147254213D; // bluechip wallet
address private walletB = 0x7dd92296299F6fC47E8F3C62b9989e2d7E6d6277; // airdrop 77 token to self
address[] private airdropAddressList = [ // advisor airdrop addresses
0xb75C8Ccd983161Da5904daf915d0d98877106B82,
0x4c64f00192DA89486C1Eec2f12bFA74CbeC413e1,
0x87a95295B64c1ea849e38c3849Da60A40f4f7E76,
0x5cae83C312B67AeF18CBD0627c0Eb67F4524A7c2,
0x7040d76C32765F1bd8D5C7f2cc8288076CC2b956,
0x295fF892A2B5941ED26Ff8a10FEcF90554092719,
0x752F405BDaF1fA55519E3F3C0c0BD155821bEed5,
0x79163A65F37129Cc8160623D64a06aA06DBB12B2,
0x9c840914715Db95DD6773155788eF1e316c4E579,
0xB9cF551E73bEC54332D76A7542FdacBb77BFA430,
0x36837e2c2893b2d34fA80694B70eb53677aa6D4a,
0x819A899c0325342CD471A485c1196d182F85860D,
0x25B7da55E37c6e02c6ED560FEAA9aeB68dbbfa65,
0x114ddEdBaD20dc9c4625776aBd17896e0D18FB26,
0x76f838819F33606393E40A8188Cf2B279cB98dF6,
0xF0504B013159a9eA19741D0A38AA29b9cc3Cf436,
0x049b916dac9b8e3C3Ee573B8df491fb2132288d0,
0xFE67FC74E3845A8352000D20A3AA200Cf4e963c3,
0x0172B6b3cB56A9B71d63C86A6B7F6d9105f5DE33
];
mapping(address => bool) public whitelisted; // whitelist address
mapping(address => uint256) private addressMintedBalance; // amount of current minted address
mapping(address => uint256 []) private addressMintedTokenId; // tokenIds of current minted address
constructor( string memory _deployURI ) ERC721("DNA PASS", "DNAP") {
}
function deployTask() private{
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _mintAmount) public payable {
require( paused == false, "The collection is currently on sale" );
uint256 supply = totalSupply();
require(_mintAmount > 0, "Mint amount cannot less than 1");
require(<FILL_ME>)
require(supply + _mintAmount <= maxSupply, "Max total supply exceeded");
require(isWhitelisted(msg.sender), "User is not whitelisted");
require(msg.value >= cost * _mintAmount, "Insufficient funds");
require(addressMintedBalance[msg.sender] + _mintAmount <= mintAddressLimit, "Max mint amount of address limit exceeded");
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
addressMintedTokenId[msg.sender].push(supply + i);
console.log("mint token : ", supply + i);
_safeMint(msg.sender, supply + i);
currentDNASupply++;
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function walletOfMintedOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/* start mint */
function startMint( uint256 _saleNum ) public onlyOwner {
}
/* pause mint */
function stopMint() public onlyOwner {
}
/* set amount limit of address mint max token */
function setMintLimit( uint256 _saleNum ) public onlyOwner {
}
/* set whitelist */
function addWhitelistUsers(address[] calldata _users) public onlyOwner {
}
/* 0: total / 1: current minting */
function getMaxSupply( uint256 _type ) public view virtual returns (uint256) {
}
/* 0: total / 1: current minting */
function getCurrentSupply( uint256 _type ) public view virtual returns (uint256) {
}
function getBalance() public onlyOwner view virtual returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| currentDNASupply+_mintAmount<=maxDNASupply,"Max DNA supply exceeded" | 452,496 | currentDNASupply+_mintAmount<=maxDNASupply |
"Max mint amount of address limit exceeded" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.1;
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "hardhat/console.sol";
contract DNA is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
string private baseURI = "";
string private baseExtension = ".json";
uint256 private maxSupply = 777;
uint256 private maxBlueSupply = 54;
uint256 private maxAdvisorSupply = 77;
uint256 private maxDNASelfSupply = 77;
uint256 private maxDNASupply = 77; // each start mint number
uint256 private currentDNASupply = 0; // current amount of minted in each starting
uint256 public mintAddressLimit = 2; // limit amount of each address is able to mint
uint256 public cost = 0.36 ether;
bool public paused = true; // start / stop
address private walletA = 0x6222B964651998e49b6dE26e59D977147254213D; // bluechip wallet
address private walletB = 0x7dd92296299F6fC47E8F3C62b9989e2d7E6d6277; // airdrop 77 token to self
address[] private airdropAddressList = [ // advisor airdrop addresses
0xb75C8Ccd983161Da5904daf915d0d98877106B82,
0x4c64f00192DA89486C1Eec2f12bFA74CbeC413e1,
0x87a95295B64c1ea849e38c3849Da60A40f4f7E76,
0x5cae83C312B67AeF18CBD0627c0Eb67F4524A7c2,
0x7040d76C32765F1bd8D5C7f2cc8288076CC2b956,
0x295fF892A2B5941ED26Ff8a10FEcF90554092719,
0x752F405BDaF1fA55519E3F3C0c0BD155821bEed5,
0x79163A65F37129Cc8160623D64a06aA06DBB12B2,
0x9c840914715Db95DD6773155788eF1e316c4E579,
0xB9cF551E73bEC54332D76A7542FdacBb77BFA430,
0x36837e2c2893b2d34fA80694B70eb53677aa6D4a,
0x819A899c0325342CD471A485c1196d182F85860D,
0x25B7da55E37c6e02c6ED560FEAA9aeB68dbbfa65,
0x114ddEdBaD20dc9c4625776aBd17896e0D18FB26,
0x76f838819F33606393E40A8188Cf2B279cB98dF6,
0xF0504B013159a9eA19741D0A38AA29b9cc3Cf436,
0x049b916dac9b8e3C3Ee573B8df491fb2132288d0,
0xFE67FC74E3845A8352000D20A3AA200Cf4e963c3,
0x0172B6b3cB56A9B71d63C86A6B7F6d9105f5DE33
];
mapping(address => bool) public whitelisted; // whitelist address
mapping(address => uint256) private addressMintedBalance; // amount of current minted address
mapping(address => uint256 []) private addressMintedTokenId; // tokenIds of current minted address
constructor( string memory _deployURI ) ERC721("DNA PASS", "DNAP") {
}
function deployTask() private{
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _mintAmount) public payable {
require( paused == false, "The collection is currently on sale" );
uint256 supply = totalSupply();
require(_mintAmount > 0, "Mint amount cannot less than 1");
require(currentDNASupply + _mintAmount <= maxDNASupply, "Max DNA supply exceeded");
require(supply + _mintAmount <= maxSupply, "Max total supply exceeded");
require(isWhitelisted(msg.sender), "User is not whitelisted");
require(msg.value >= cost * _mintAmount, "Insufficient funds");
require(<FILL_ME>)
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
addressMintedTokenId[msg.sender].push(supply + i);
console.log("mint token : ", supply + i);
_safeMint(msg.sender, supply + i);
currentDNASupply++;
}
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function walletOfMintedOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/* start mint */
function startMint( uint256 _saleNum ) public onlyOwner {
}
/* pause mint */
function stopMint() public onlyOwner {
}
/* set amount limit of address mint max token */
function setMintLimit( uint256 _saleNum ) public onlyOwner {
}
/* set whitelist */
function addWhitelistUsers(address[] calldata _users) public onlyOwner {
}
/* 0: total / 1: current minting */
function getMaxSupply( uint256 _type ) public view virtual returns (uint256) {
}
/* 0: total / 1: current minting */
function getCurrentSupply( uint256 _type ) public view virtual returns (uint256) {
}
function getBalance() public onlyOwner view virtual returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| addressMintedBalance[msg.sender]+_mintAmount<=mintAddressLimit,"Max mint amount of address limit exceeded" | 452,496 | addressMintedBalance[msg.sender]+_mintAmount<=mintAddressLimit |
"The amount of sale token is over the totalSupply" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.1;
import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "hardhat/console.sol";
contract DNA is ERC721, ERC721Enumerable, Ownable {
using Strings for uint256;
string private baseURI = "";
string private baseExtension = ".json";
uint256 private maxSupply = 777;
uint256 private maxBlueSupply = 54;
uint256 private maxAdvisorSupply = 77;
uint256 private maxDNASelfSupply = 77;
uint256 private maxDNASupply = 77; // each start mint number
uint256 private currentDNASupply = 0; // current amount of minted in each starting
uint256 public mintAddressLimit = 2; // limit amount of each address is able to mint
uint256 public cost = 0.36 ether;
bool public paused = true; // start / stop
address private walletA = 0x6222B964651998e49b6dE26e59D977147254213D; // bluechip wallet
address private walletB = 0x7dd92296299F6fC47E8F3C62b9989e2d7E6d6277; // airdrop 77 token to self
address[] private airdropAddressList = [ // advisor airdrop addresses
0xb75C8Ccd983161Da5904daf915d0d98877106B82,
0x4c64f00192DA89486C1Eec2f12bFA74CbeC413e1,
0x87a95295B64c1ea849e38c3849Da60A40f4f7E76,
0x5cae83C312B67AeF18CBD0627c0Eb67F4524A7c2,
0x7040d76C32765F1bd8D5C7f2cc8288076CC2b956,
0x295fF892A2B5941ED26Ff8a10FEcF90554092719,
0x752F405BDaF1fA55519E3F3C0c0BD155821bEed5,
0x79163A65F37129Cc8160623D64a06aA06DBB12B2,
0x9c840914715Db95DD6773155788eF1e316c4E579,
0xB9cF551E73bEC54332D76A7542FdacBb77BFA430,
0x36837e2c2893b2d34fA80694B70eb53677aa6D4a,
0x819A899c0325342CD471A485c1196d182F85860D,
0x25B7da55E37c6e02c6ED560FEAA9aeB68dbbfa65,
0x114ddEdBaD20dc9c4625776aBd17896e0D18FB26,
0x76f838819F33606393E40A8188Cf2B279cB98dF6,
0xF0504B013159a9eA19741D0A38AA29b9cc3Cf436,
0x049b916dac9b8e3C3Ee573B8df491fb2132288d0,
0xFE67FC74E3845A8352000D20A3AA200Cf4e963c3,
0x0172B6b3cB56A9B71d63C86A6B7F6d9105f5DE33
];
mapping(address => bool) public whitelisted; // whitelist address
mapping(address => uint256) private addressMintedBalance; // amount of current minted address
mapping(address => uint256 []) private addressMintedTokenId; // tokenIds of current minted address
constructor( string memory _deployURI ) ERC721("DNA PASS", "DNAP") {
}
function deployTask() private{
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(uint256 _mintAmount) public payable {
}
function isWhitelisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function walletOfMintedOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
/* start mint */
function startMint( uint256 _saleNum ) public onlyOwner {
uint256 _currentSupply = totalSupply();
require(<FILL_ME>)
paused = false;
maxDNASupply = _saleNum;
currentDNASupply = 0;
}
/* pause mint */
function stopMint() public onlyOwner {
}
/* set amount limit of address mint max token */
function setMintLimit( uint256 _saleNum ) public onlyOwner {
}
/* set whitelist */
function addWhitelistUsers(address[] calldata _users) public onlyOwner {
}
/* 0: total / 1: current minting */
function getMaxSupply( uint256 _type ) public view virtual returns (uint256) {
}
/* 0: total / 1: current minting */
function getCurrentSupply( uint256 _type ) public view virtual returns (uint256) {
}
function getBalance() public onlyOwner view virtual returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override(ERC721, ERC721Enumerable) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| _currentSupply+_saleNum<=maxSupply,"The amount of sale token is over the totalSupply" | 452,496 | _currentSupply+_saleNum<=maxSupply |
"Invalid Signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts-upgradeable/token/ERC1155/ERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/common/ERC2981Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable//utils/cryptography/ECDSAUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155BurnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155SupplyUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
contract WagmiTraits is Initializable, ERC1155Upgradeable, ERC2981Upgradeable, ReentrancyGuardUpgradeable, OwnableUpgradeable, PausableUpgradeable, ERC1155BurnableUpgradeable, ERC1155SupplyUpgradeable, DefaultOperatorFiltererUpgradeable {
string public name = "WAGMI Traits";
string public symbol = "WAT";
address private signer;
address private sales;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
}
function initialize() initializer public {
}
struct Transfer {
address holder;
uint256 traitId;
uint256 amount;
}
struct Trait {
uint256 traitId;
uint256 amount;
}
event BuyTrait (
address indexed buyer,
Transfer[] transfers
);
event ClaimTrait (
address indexed receiver,
Trait[] traits
);
function setSigner(address _signer) external onlyOwner {
}
function setSales(address _sales) external onlyOwner {
}
function setURI(string memory newuri) public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function teamMint(uint256 _traitId, address receiver, uint256 amount)
external
onlyOwner
{
}
function claim(bytes calldata signature, Trait[] memory _traits)
external
nonReentrant
{
require(<FILL_ME>)
uint256[] memory ids;
uint256[] memory amounts;
for (uint256 i = 0; i < _traits.length; ++i) {
ids[i] = _traits[i].traitId;
amounts[i] = _traits[i].amount;
}
_mintBatch(msg.sender, ids, amounts, "");
emit ClaimTrait(msg.sender, _traits);
}
function buyTraits(Transfer[] memory _transfers)
external
onlySales
{
}
function sendAirdrop(Transfer[] memory _transfers)
external
onlyOwner
{
}
function _isVerifiedSignature(bytes calldata signature)
internal
view
returns (bool)
{
}
/**
* @dev See {IERC1155-setApprovalForAll}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
/**
* @dev See {IERC1155-safeTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
* In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155Upgradeable, ERC2981Upgradeable) returns (bool) {
}
function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
internal
whenNotPaused
override(ERC1155Upgradeable, ERC1155SupplyUpgradeable)
{
}
function withdraw() external onlyOwner {
}
modifier onlySales() {
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
| _isVerifiedSignature(signature),"Invalid Signature" | 452,593 | _isVerifiedSignature(signature) |
"Maximum wallet limited has been exceeded" | // SPDX-License-Identifier: Unlicensed
/*
DISCOVER YOUR ESSENCE, CONNECT WITH SOULMATES, BUILD YOUR EMPIRE
Website: https://www.soulcial.pro
Telegram: https://t.me/soulcial_erc20
Twitter: https://twitter.com/soulcial_erc20
Dapp: https://app.soulcial.pro
*/
pragma solidity 0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
// Set original owner
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
// Return current owner
function owner() public view virtual returns (address) {
}
// Restrict function to contract owner only
modifier onlyOwner() {
}
// Renounce ownership of the contract
function renounceOwnership() public virtual onlyOwner {
}
// Transfer the contract to to a new owner
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
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;
}
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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Router01 {
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 quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
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 IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Soulcial is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rBalance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) _isExcludedFromFee;
string private _name = "Soulcial";
string private _symbol = "SOUL";
uint8 private _decimals = 9;
uint256 private _totalSupply = 10 ** 9 * 10**_decimals;
uint8 _countSoulcialTx = 0;
uint8 _swapSoulcialTrigger = 2;
uint256 _totalFee = 2100;
uint256 _buyFee = 21;
uint256 _sellFee = 21;
uint256 _previousTotalFee = _totalFee;
uint256 _previousBuyFee = _buyFee;
uint256 _previousSellFee = _sellFee;
uint256 _maxWalletToken = 2 * _totalSupply / 100;
uint256 _swpaThreshold = _totalSupply / 10000;
uint256 _previousMaxWalletToken = _maxWalletToken;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool _inSwapAndLiquify;
bool _swapAndLiquifyEnabled = true;
address payable _taxWallet = payable(0x5D3A7DdBE25445add5b36aB3D1Fb1a00aF05Db7A);
address payable private DEAD = payable(0x000000000000000000000000000000000000dEaD);
modifier lockTheSwap {
}
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 removeAllSoulcialFee() private {
}
function sendToSoulcialWallet(address payable wallet, uint256 amount) private {
}
function swapSoulcialAndLiquidify(uint256 contractTokenBalance) private lockTheSwap {
}
function swapSoulcialForETH(uint256 tokenAmount) private {
}
function _getSoulcialValues(uint256 tAmount) private view returns (uint256, uint256) {
}
function _tokenTransfer(address sender, address recipient, uint256 amount,bool _takeFee) private {
}
function _transferSoulcialTokens(address sender, address recipient, uint256 tAmount) private {
}
function removeSoulcialLimits() external onlyOwner {
}
function restoreAllSoulcialFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
if (to != owner() &&
to != _taxWallet &&
to != address(this) &&
to != uniswapV2Pair &&
to != DEAD &&
from != owner()){
uint256 holdBalance = balanceOf(to);
require(<FILL_ME>)
}
require(from != address(0) && to != address(0), "ERR: Using 0 address!");
require(amount > 0, "Token value must be higher than zero.");
if(_countSoulcialTx >= _swapSoulcialTrigger &&
amount > _swpaThreshold &&
!_inSwapAndLiquify &&
!_isExcludedFromFee[from] &&
to == uniswapV2Pair &&
_swapAndLiquifyEnabled )
{
_countSoulcialTx = 0;
uint256 contractTokenBalance = balanceOf(address(this));
if(contractTokenBalance > 0){
swapSoulcialAndLiquidify(contractTokenBalance);
}
}
bool _takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to] || (from != uniswapV2Pair && to != uniswapV2Pair)){
_takeFee = false;
} else if (from == uniswapV2Pair){
_totalFee = _buyFee;
} else if (to == uniswapV2Pair){
_totalFee = _sellFee;
}
_tokenTransfer(from,to,amount,_takeFee);
}
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) {
}
receive() external payable {}
}
| (holdBalance+amount)<=_maxWalletToken,"Maximum wallet limited has been exceeded" | 452,635 | (holdBalance+amount)<=_maxWalletToken |
"trading is already open" | /*
// Website: https://ravecoin.fun/
// Twitter: https://twitter.com/RaveCoinETH
// Telegram: https://t.me/ravecoinfun
.-------. ____ ,---. ,---. .-''-.
| _ _ \ .' __ `. | / | | .'_ _ \
| ( ' ) | / ' \ \| | | .'/ ( ` ) '
|(_ o _) / |___| / || | _ | |. (_ o _) |
| (_,_).' __ _.-` || _( )_ || (_,_)___|
| |\ \ | |.' _ |\ (_ o._) /' \ .---.
| | \ `' /| _( )_ | \ (_,_) / \ `-' /
| | \ / \ (_ o _) / \ / \ /
''-' `'-' '.(_,_).' `---` `'-..-'
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval (address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract RAVE is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _taxWallet;
uint256 firstBlock;
uint256 private _preventSwapBefore=3;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 369369369369 * 10**_decimals;
string private constant _name = unicode"RAVEcoin";
string private constant _symbol = unicode"RAVE";
uint256 public _maxTxAmount = 36936936936 * 10**_decimals;
uint256 public _maxWalletSize = 36936936936 * 10**_decimals;
uint256 public _taxSwapThreshold= 3693693693 * 10**_decimals;
uint256 public _maxTaxSwap= 36936936936 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private exchangeAllowed;
bool private inSwap = false;
bool private onSwap = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function openTrading() external onlyOwner() {
require(<FILL_ME>)
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
firstBlock = block.number;
exchangeAllowed = true;
onSwap = true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function _transfer(address from, address to, uint256 amount) private {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
receive() external payable {}
}
| !exchangeAllowed,"trading is already open" | 452,876 | !exchangeAllowed |
"Can't mint more than total supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
contract NFT is Ownable, ERC721A, DefaultOperatorFilterer {
string public uriPrefix = '';
string public uriSuffix = '.json';
uint256 public max_supply = 500;
uint256 public amountMintPerAccount = 8;
uint256 public price = 0.02 ether;
bytes32 public whitelistRoot;
bool public publicSaleEnabled;
bool public mintEnabled;
event MintSuccessful(address user, uint256 totalSupplyBeforeMint, uint256 _quantity);
constructor(
address _ownerAddress,
bytes32 _whitelistRoot,
address[] memory _minterAddresses,
uint256[] memory _tokenAmount
) ERC721A ("Mystic Motors", "MYSTIC") {
}
function mint(uint256 _quantity, bytes32[] memory _proof) external payable {
require(mintEnabled, 'Minting is not enabled');
require(balanceOf(msg.sender) < amountMintPerAccount, 'Each address may only mint x NFTs!');
require(<FILL_ME>)
require(publicSaleEnabled || isValid(_proof, keccak256(abi.encodePacked(msg.sender))), 'You are not whitelisted');
require(msg.value >= price * _quantity, "Not enough ETH sent; check price!");
_mint(msg.sender, _quantity);
emit MintSuccessful(msg.sender, totalSupply(), _quantity);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal pure override returns (string memory) {
}
function baseTokenURI() public pure returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function setAmountMintPerAccount(uint _amountMintPerAccount) public onlyOwner {
}
function setPublicSaleEnabled(bool _state) public onlyOwner {
}
function setWhitelistRoot(bytes32 _whitelistRoot) public onlyOwner {
}
function isValid(bytes32[] memory _proof, bytes32 _leaf) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function setMintEnabled(bool _state) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function airdrop(address _user, uint256 _quantity) external onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
}
| totalSupply()+_quantity<=max_supply,"Can't mint more than total supply" | 453,041 | totalSupply()+_quantity<=max_supply |
'You are not whitelisted' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {DefaultOperatorFilterer} from "./DefaultOperatorFilterer.sol";
contract NFT is Ownable, ERC721A, DefaultOperatorFilterer {
string public uriPrefix = '';
string public uriSuffix = '.json';
uint256 public max_supply = 500;
uint256 public amountMintPerAccount = 8;
uint256 public price = 0.02 ether;
bytes32 public whitelistRoot;
bool public publicSaleEnabled;
bool public mintEnabled;
event MintSuccessful(address user, uint256 totalSupplyBeforeMint, uint256 _quantity);
constructor(
address _ownerAddress,
bytes32 _whitelistRoot,
address[] memory _minterAddresses,
uint256[] memory _tokenAmount
) ERC721A ("Mystic Motors", "MYSTIC") {
}
function mint(uint256 _quantity, bytes32[] memory _proof) external payable {
require(mintEnabled, 'Minting is not enabled');
require(balanceOf(msg.sender) < amountMintPerAccount, 'Each address may only mint x NFTs!');
require(totalSupply() + _quantity <= max_supply, "Can't mint more than total supply");
require(<FILL_ME>)
require(msg.value >= price * _quantity, "Not enough ETH sent; check price!");
_mint(msg.sender, _quantity);
emit MintSuccessful(msg.sender, totalSupply(), _quantity);
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal pure override returns (string memory) {
}
function baseTokenURI() public pure returns (string memory) {
}
function contractURI() public pure returns (string memory) {
}
function setAmountMintPerAccount(uint _amountMintPerAccount) public onlyOwner {
}
function setPublicSaleEnabled(bool _state) public onlyOwner {
}
function setWhitelistRoot(bytes32 _whitelistRoot) public onlyOwner {
}
function isValid(bytes32[] memory _proof, bytes32 _leaf) public view returns (bool) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator(from)
{
}
function setMintEnabled(bool _state) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function airdrop(address _user, uint256 _quantity) external onlyOwner {
}
function _startTokenId() internal view override returns (uint256) {
}
}
| publicSaleEnabled||isValid(_proof,keccak256(abi.encodePacked(msg.sender))),'You are not whitelisted' | 453,041 | publicSaleEnabled||isValid(_proof,keccak256(abi.encodePacked(msg.sender))) |
"Presale is yet to start or its over" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
import "./BaseWhitelist.sol";
abstract contract PreSale is BaseWhitelist {
// total quantity of NFTs available for presale
uint256 public presaleQuantity;
// tracks the number of NFTs minted on presale
uint256 public presaleSupply;
// presale minting price
uint256 public presaleMintPrice;
// maximum mints per whitelisted wallet
uint256 public presaleMaxMintPerWallet;
// maximum mints per transaction
uint256 public presaleMaxMintPerTx;
// presale start time
uint256 public presaleStartingTimestamp;
// presale end time
uint256 public presaleEndingTimestamp;
// merklee root
bytes32 public merkleRoot;
// presale status
bool public isPreSaleActive;
// tracks number of times a whitelisted address has minted
mapping(address => uint256) public presaleMintCountPerWallet;
struct PreSaleConfig {
uint256 quantity;
uint256 maxMint;
uint256 maxMintTx;
uint256 price;
uint256 startTime;
uint256 endTime;
}
function __BasePreSale_init(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
function __BasePreSale_init_unchained(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
/***********************************************************************
MODIFIERS
*************************************************************************/
modifier callerIsUser() {
}
modifier whenPreSaleIsActive() {
}
function hasPreSaleStarted() public view returns (bool) {
}
/***********************************************************************
PUBLIC FUNCTIONS
*************************************************************************/
function preSaleMint(bytes32[] calldata _merkleProof, uint8 quantity)
external
payable
callerIsUser
whenPreSaleIsActive
nonReentrant
{
require(<FILL_ME>)
require(
_isWhitelisted(_merkleProof, _msgSender()),
"Address is not whitelisted"
);
require(presaleSupply < presaleQuantity, "Presale has sold out");
require(
presaleSupply + quantity <= presaleQuantity,
"Exceeds presale NFTs remaining"
);
if (presaleMaxMintPerTx > 0) {
require(
quantity <= presaleMaxMintPerTx,
"Exceeds mints allowed per transaction"
);
}
if (presaleMaxMintPerWallet > 0) {
require(
presaleMintCountPerWallet[_msgSender()] + quantity <=
presaleMaxMintPerWallet,
"Exceeds mints allowed per wallet"
);
}
presaleMintCountPerWallet[_msgSender()] += quantity;
presaleSupply += quantity;
_safeMint(_msgSender(), quantity);
_refundIfOver(presaleMintPrice * quantity);
}
/***********************************************************************
ONLY OWNER FUNCTIONS
*************************************************************************/
function airdrop(uint8 quantity, address recipient)
external
onlyOwner
nonReentrant
{
}
// /**===========================================================================
// Setter Functions
// ============================================================================== */
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function _setPresaleState() internal onlyInitializing {
}
function setPresaleQuantity(uint256 quantity) external onlyOwner {
}
function setPresaleMaxMint(uint256 maxMint) external onlyOwner {
}
function setPresaleMaxMintTx(uint256 maxMintTx) external onlyOwner {
}
function setPresaleMintPrice(uint256 price) external onlyOwner {
}
function setPresaleStartTime(uint256 startTime) external onlyOwner {
}
function setPresaleEndTime(uint256 endTime) external onlyOwner {
}
function setPresaleStatus() external onlyOwner {
}
/***********************************************************************
INTERNAL FUNCTIONS
*************************************************************************/
function _isWhitelisted(bytes32[] calldata _merkleProof, address sender)
private
view
returns (bool)
{
}
}
| hasPreSaleStarted(),"Presale is yet to start or its over" | 453,059 | hasPreSaleStarted() |
"Address is not whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
import "./BaseWhitelist.sol";
abstract contract PreSale is BaseWhitelist {
// total quantity of NFTs available for presale
uint256 public presaleQuantity;
// tracks the number of NFTs minted on presale
uint256 public presaleSupply;
// presale minting price
uint256 public presaleMintPrice;
// maximum mints per whitelisted wallet
uint256 public presaleMaxMintPerWallet;
// maximum mints per transaction
uint256 public presaleMaxMintPerTx;
// presale start time
uint256 public presaleStartingTimestamp;
// presale end time
uint256 public presaleEndingTimestamp;
// merklee root
bytes32 public merkleRoot;
// presale status
bool public isPreSaleActive;
// tracks number of times a whitelisted address has minted
mapping(address => uint256) public presaleMintCountPerWallet;
struct PreSaleConfig {
uint256 quantity;
uint256 maxMint;
uint256 maxMintTx;
uint256 price;
uint256 startTime;
uint256 endTime;
}
function __BasePreSale_init(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
function __BasePreSale_init_unchained(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
/***********************************************************************
MODIFIERS
*************************************************************************/
modifier callerIsUser() {
}
modifier whenPreSaleIsActive() {
}
function hasPreSaleStarted() public view returns (bool) {
}
/***********************************************************************
PUBLIC FUNCTIONS
*************************************************************************/
function preSaleMint(bytes32[] calldata _merkleProof, uint8 quantity)
external
payable
callerIsUser
whenPreSaleIsActive
nonReentrant
{
require(hasPreSaleStarted(), "Presale is yet to start or its over");
require(<FILL_ME>)
require(presaleSupply < presaleQuantity, "Presale has sold out");
require(
presaleSupply + quantity <= presaleQuantity,
"Exceeds presale NFTs remaining"
);
if (presaleMaxMintPerTx > 0) {
require(
quantity <= presaleMaxMintPerTx,
"Exceeds mints allowed per transaction"
);
}
if (presaleMaxMintPerWallet > 0) {
require(
presaleMintCountPerWallet[_msgSender()] + quantity <=
presaleMaxMintPerWallet,
"Exceeds mints allowed per wallet"
);
}
presaleMintCountPerWallet[_msgSender()] += quantity;
presaleSupply += quantity;
_safeMint(_msgSender(), quantity);
_refundIfOver(presaleMintPrice * quantity);
}
/***********************************************************************
ONLY OWNER FUNCTIONS
*************************************************************************/
function airdrop(uint8 quantity, address recipient)
external
onlyOwner
nonReentrant
{
}
// /**===========================================================================
// Setter Functions
// ============================================================================== */
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function _setPresaleState() internal onlyInitializing {
}
function setPresaleQuantity(uint256 quantity) external onlyOwner {
}
function setPresaleMaxMint(uint256 maxMint) external onlyOwner {
}
function setPresaleMaxMintTx(uint256 maxMintTx) external onlyOwner {
}
function setPresaleMintPrice(uint256 price) external onlyOwner {
}
function setPresaleStartTime(uint256 startTime) external onlyOwner {
}
function setPresaleEndTime(uint256 endTime) external onlyOwner {
}
function setPresaleStatus() external onlyOwner {
}
/***********************************************************************
INTERNAL FUNCTIONS
*************************************************************************/
function _isWhitelisted(bytes32[] calldata _merkleProof, address sender)
private
view
returns (bool)
{
}
}
| _isWhitelisted(_merkleProof,_msgSender()),"Address is not whitelisted" | 453,059 | _isWhitelisted(_merkleProof,_msgSender()) |
"Exceeds presale NFTs remaining" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
import "./BaseWhitelist.sol";
abstract contract PreSale is BaseWhitelist {
// total quantity of NFTs available for presale
uint256 public presaleQuantity;
// tracks the number of NFTs minted on presale
uint256 public presaleSupply;
// presale minting price
uint256 public presaleMintPrice;
// maximum mints per whitelisted wallet
uint256 public presaleMaxMintPerWallet;
// maximum mints per transaction
uint256 public presaleMaxMintPerTx;
// presale start time
uint256 public presaleStartingTimestamp;
// presale end time
uint256 public presaleEndingTimestamp;
// merklee root
bytes32 public merkleRoot;
// presale status
bool public isPreSaleActive;
// tracks number of times a whitelisted address has minted
mapping(address => uint256) public presaleMintCountPerWallet;
struct PreSaleConfig {
uint256 quantity;
uint256 maxMint;
uint256 maxMintTx;
uint256 price;
uint256 startTime;
uint256 endTime;
}
function __BasePreSale_init(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
function __BasePreSale_init_unchained(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
/***********************************************************************
MODIFIERS
*************************************************************************/
modifier callerIsUser() {
}
modifier whenPreSaleIsActive() {
}
function hasPreSaleStarted() public view returns (bool) {
}
/***********************************************************************
PUBLIC FUNCTIONS
*************************************************************************/
function preSaleMint(bytes32[] calldata _merkleProof, uint8 quantity)
external
payable
callerIsUser
whenPreSaleIsActive
nonReentrant
{
require(hasPreSaleStarted(), "Presale is yet to start or its over");
require(
_isWhitelisted(_merkleProof, _msgSender()),
"Address is not whitelisted"
);
require(presaleSupply < presaleQuantity, "Presale has sold out");
require(<FILL_ME>)
if (presaleMaxMintPerTx > 0) {
require(
quantity <= presaleMaxMintPerTx,
"Exceeds mints allowed per transaction"
);
}
if (presaleMaxMintPerWallet > 0) {
require(
presaleMintCountPerWallet[_msgSender()] + quantity <=
presaleMaxMintPerWallet,
"Exceeds mints allowed per wallet"
);
}
presaleMintCountPerWallet[_msgSender()] += quantity;
presaleSupply += quantity;
_safeMint(_msgSender(), quantity);
_refundIfOver(presaleMintPrice * quantity);
}
/***********************************************************************
ONLY OWNER FUNCTIONS
*************************************************************************/
function airdrop(uint8 quantity, address recipient)
external
onlyOwner
nonReentrant
{
}
// /**===========================================================================
// Setter Functions
// ============================================================================== */
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function _setPresaleState() internal onlyInitializing {
}
function setPresaleQuantity(uint256 quantity) external onlyOwner {
}
function setPresaleMaxMint(uint256 maxMint) external onlyOwner {
}
function setPresaleMaxMintTx(uint256 maxMintTx) external onlyOwner {
}
function setPresaleMintPrice(uint256 price) external onlyOwner {
}
function setPresaleStartTime(uint256 startTime) external onlyOwner {
}
function setPresaleEndTime(uint256 endTime) external onlyOwner {
}
function setPresaleStatus() external onlyOwner {
}
/***********************************************************************
INTERNAL FUNCTIONS
*************************************************************************/
function _isWhitelisted(bytes32[] calldata _merkleProof, address sender)
private
view
returns (bool)
{
}
}
| presaleSupply+quantity<=presaleQuantity,"Exceeds presale NFTs remaining" | 453,059 | presaleSupply+quantity<=presaleQuantity |
"Exceeds mints allowed per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
import "./BaseWhitelist.sol";
abstract contract PreSale is BaseWhitelist {
// total quantity of NFTs available for presale
uint256 public presaleQuantity;
// tracks the number of NFTs minted on presale
uint256 public presaleSupply;
// presale minting price
uint256 public presaleMintPrice;
// maximum mints per whitelisted wallet
uint256 public presaleMaxMintPerWallet;
// maximum mints per transaction
uint256 public presaleMaxMintPerTx;
// presale start time
uint256 public presaleStartingTimestamp;
// presale end time
uint256 public presaleEndingTimestamp;
// merklee root
bytes32 public merkleRoot;
// presale status
bool public isPreSaleActive;
// tracks number of times a whitelisted address has minted
mapping(address => uint256) public presaleMintCountPerWallet;
struct PreSaleConfig {
uint256 quantity;
uint256 maxMint;
uint256 maxMintTx;
uint256 price;
uint256 startTime;
uint256 endTime;
}
function __BasePreSale_init(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
function __BasePreSale_init_unchained(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
/***********************************************************************
MODIFIERS
*************************************************************************/
modifier callerIsUser() {
}
modifier whenPreSaleIsActive() {
}
function hasPreSaleStarted() public view returns (bool) {
}
/***********************************************************************
PUBLIC FUNCTIONS
*************************************************************************/
function preSaleMint(bytes32[] calldata _merkleProof, uint8 quantity)
external
payable
callerIsUser
whenPreSaleIsActive
nonReentrant
{
require(hasPreSaleStarted(), "Presale is yet to start or its over");
require(
_isWhitelisted(_merkleProof, _msgSender()),
"Address is not whitelisted"
);
require(presaleSupply < presaleQuantity, "Presale has sold out");
require(
presaleSupply + quantity <= presaleQuantity,
"Exceeds presale NFTs remaining"
);
if (presaleMaxMintPerTx > 0) {
require(
quantity <= presaleMaxMintPerTx,
"Exceeds mints allowed per transaction"
);
}
if (presaleMaxMintPerWallet > 0) {
require(<FILL_ME>)
}
presaleMintCountPerWallet[_msgSender()] += quantity;
presaleSupply += quantity;
_safeMint(_msgSender(), quantity);
_refundIfOver(presaleMintPrice * quantity);
}
/***********************************************************************
ONLY OWNER FUNCTIONS
*************************************************************************/
function airdrop(uint8 quantity, address recipient)
external
onlyOwner
nonReentrant
{
}
// /**===========================================================================
// Setter Functions
// ============================================================================== */
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function _setPresaleState() internal onlyInitializing {
}
function setPresaleQuantity(uint256 quantity) external onlyOwner {
}
function setPresaleMaxMint(uint256 maxMint) external onlyOwner {
}
function setPresaleMaxMintTx(uint256 maxMintTx) external onlyOwner {
}
function setPresaleMintPrice(uint256 price) external onlyOwner {
}
function setPresaleStartTime(uint256 startTime) external onlyOwner {
}
function setPresaleEndTime(uint256 endTime) external onlyOwner {
}
function setPresaleStatus() external onlyOwner {
}
/***********************************************************************
INTERNAL FUNCTIONS
*************************************************************************/
function _isWhitelisted(bytes32[] calldata _merkleProof, address sender)
private
view
returns (bool)
{
}
}
| presaleMintCountPerWallet[_msgSender()]+quantity<=presaleMaxMintPerWallet,"Exceeds mints allowed per wallet" | 453,059 | presaleMintCountPerWallet[_msgSender()]+quantity<=presaleMaxMintPerWallet |
"Not enough NFTs to airdrop" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
import "./BaseWhitelist.sol";
abstract contract PreSale is BaseWhitelist {
// total quantity of NFTs available for presale
uint256 public presaleQuantity;
// tracks the number of NFTs minted on presale
uint256 public presaleSupply;
// presale minting price
uint256 public presaleMintPrice;
// maximum mints per whitelisted wallet
uint256 public presaleMaxMintPerWallet;
// maximum mints per transaction
uint256 public presaleMaxMintPerTx;
// presale start time
uint256 public presaleStartingTimestamp;
// presale end time
uint256 public presaleEndingTimestamp;
// merklee root
bytes32 public merkleRoot;
// presale status
bool public isPreSaleActive;
// tracks number of times a whitelisted address has minted
mapping(address => uint256) public presaleMintCountPerWallet;
struct PreSaleConfig {
uint256 quantity;
uint256 maxMint;
uint256 maxMintTx;
uint256 price;
uint256 startTime;
uint256 endTime;
}
function __BasePreSale_init(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
function __BasePreSale_init_unchained(PreSaleConfig memory presale)
internal
onlyInitializing
{
}
/***********************************************************************
MODIFIERS
*************************************************************************/
modifier callerIsUser() {
}
modifier whenPreSaleIsActive() {
}
function hasPreSaleStarted() public view returns (bool) {
}
/***********************************************************************
PUBLIC FUNCTIONS
*************************************************************************/
function preSaleMint(bytes32[] calldata _merkleProof, uint8 quantity)
external
payable
callerIsUser
whenPreSaleIsActive
nonReentrant
{
}
/***********************************************************************
ONLY OWNER FUNCTIONS
*************************************************************************/
function airdrop(uint8 quantity, address recipient)
external
onlyOwner
nonReentrant
{
uint256 publicSaleQuantity = totalQuantity - presaleQuantity;
require(<FILL_ME>)
supply += quantity;
_safeMint(recipient, quantity);
}
// /**===========================================================================
// Setter Functions
// ============================================================================== */
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function _setPresaleState() internal onlyInitializing {
}
function setPresaleQuantity(uint256 quantity) external onlyOwner {
}
function setPresaleMaxMint(uint256 maxMint) external onlyOwner {
}
function setPresaleMaxMintTx(uint256 maxMintTx) external onlyOwner {
}
function setPresaleMintPrice(uint256 price) external onlyOwner {
}
function setPresaleStartTime(uint256 startTime) external onlyOwner {
}
function setPresaleEndTime(uint256 endTime) external onlyOwner {
}
function setPresaleStatus() external onlyOwner {
}
/***********************************************************************
INTERNAL FUNCTIONS
*************************************************************************/
function _isWhitelisted(bytes32[] calldata _merkleProof, address sender)
private
view
returns (bool)
{
}
}
| supply+quantity<=publicSaleQuantity,"Not enough NFTs to airdrop" | 453,059 | supply+quantity<=publicSaleQuantity |
"Sale is yet to start or its over" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "contracts/extensions/PreSale.sol";
import "contracts/interfaces/IMMContract.sol";
contract WLClassicMint is PreSale {
// template type and version
bytes32 private constant TEMPLATE_TYPE = bytes32("WLClassicMint");
uint256 private constant TEMPLATE_VERSION = 1;
// maximum mint per public wallet
uint256 public maxMintPerWallet;
// maximum mint per each transaction
uint256 public maxMintPerTx;
// public sale mint price
uint256 public mintPrice;
// public sale start time
uint256 public startingTimestamp;
// public sale end time
uint256 public endingTimestamp;
// tracks the number of times a public address has minted
mapping(address => uint256) public mintCountPerWallet;
struct ContractConfig {
string contractURI;
bool delayReveal;
address[] payees;
uint256[] shares;
address royaltyRecipient;
uint96 royaltyFraction;
bytes32 merkleRoot;
}
struct PublicSaleConfig {
uint256 quantity;
uint256 maxMint;
uint256 maxMintTx;
uint256 price;
uint256 startTime;
uint256 endTime;
}
function initialize(
address owner,
address trustedForwarder,
string memory name,
string memory symbol,
ContractConfig memory contractConfig,
PublicSaleConfig memory publicSale,
PreSaleConfig memory preSale
) external initializerERC721A initializer {
}
/***********************************************************************
CONTRACT METADATA
*************************************************************************/
// Returns the module type of the template.
function contractType() external pure returns (bytes32) {
}
// Returns the version of the template.
function contractVersion() external pure returns (uint8) {
}
/***********************************************************************
MODIFIERS
*************************************************************************/
modifier whenSaleIsActive() {
}
/***********************************************************************
PUBLIC FUNCTIONS
*************************************************************************/
function hasSaleStarted() public view returns (bool) {
}
function mint(uint8 quantity)
external
payable
callerIsUser
whenSaleIsActive
nonReentrant
{
require(<FILL_ME>)
uint256 publicSaleQuantity = totalQuantity - presaleQuantity;
require(supply < publicSaleQuantity, "Public Sale has sold out");
require(
supply + quantity <= publicSaleQuantity,
"Exceeds total NFTs remaining"
);
if (maxMintPerTx > 0) {
require(
quantity <= maxMintPerTx,
"Exceeds mints allowed per transaction"
);
}
if (maxMintPerWallet > 0) {
require(
mintCountPerWallet[_msgSender()] + quantity <= maxMintPerWallet,
"Exceeds mints allowed per wallet"
);
}
mintCountPerWallet[_msgSender()] += quantity;
supply += quantity;
_safeMint(_msgSender(), quantity);
_refundIfOver(mintPrice * quantity);
}
/**===========================================================================
Setter Functions
============================================================================== */
function setTotalQuantity(uint256 quantity) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setMaxMintTx(uint256 maxMintTx) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setStartTime(uint256 startTime) external onlyOwner {
}
function setEndTime(uint256 endTime) external onlyOwner {
}
}
| hasSaleStarted(),"Sale is yet to start or its over" | 453,062 | hasSaleStarted() |
"Exceeds mints allowed per wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "contracts/extensions/PreSale.sol";
import "contracts/interfaces/IMMContract.sol";
contract WLClassicMint is PreSale {
// template type and version
bytes32 private constant TEMPLATE_TYPE = bytes32("WLClassicMint");
uint256 private constant TEMPLATE_VERSION = 1;
// maximum mint per public wallet
uint256 public maxMintPerWallet;
// maximum mint per each transaction
uint256 public maxMintPerTx;
// public sale mint price
uint256 public mintPrice;
// public sale start time
uint256 public startingTimestamp;
// public sale end time
uint256 public endingTimestamp;
// tracks the number of times a public address has minted
mapping(address => uint256) public mintCountPerWallet;
struct ContractConfig {
string contractURI;
bool delayReveal;
address[] payees;
uint256[] shares;
address royaltyRecipient;
uint96 royaltyFraction;
bytes32 merkleRoot;
}
struct PublicSaleConfig {
uint256 quantity;
uint256 maxMint;
uint256 maxMintTx;
uint256 price;
uint256 startTime;
uint256 endTime;
}
function initialize(
address owner,
address trustedForwarder,
string memory name,
string memory symbol,
ContractConfig memory contractConfig,
PublicSaleConfig memory publicSale,
PreSaleConfig memory preSale
) external initializerERC721A initializer {
}
/***********************************************************************
CONTRACT METADATA
*************************************************************************/
// Returns the module type of the template.
function contractType() external pure returns (bytes32) {
}
// Returns the version of the template.
function contractVersion() external pure returns (uint8) {
}
/***********************************************************************
MODIFIERS
*************************************************************************/
modifier whenSaleIsActive() {
}
/***********************************************************************
PUBLIC FUNCTIONS
*************************************************************************/
function hasSaleStarted() public view returns (bool) {
}
function mint(uint8 quantity)
external
payable
callerIsUser
whenSaleIsActive
nonReentrant
{
require(hasSaleStarted(), "Sale is yet to start or its over");
uint256 publicSaleQuantity = totalQuantity - presaleQuantity;
require(supply < publicSaleQuantity, "Public Sale has sold out");
require(
supply + quantity <= publicSaleQuantity,
"Exceeds total NFTs remaining"
);
if (maxMintPerTx > 0) {
require(
quantity <= maxMintPerTx,
"Exceeds mints allowed per transaction"
);
}
if (maxMintPerWallet > 0) {
require(<FILL_ME>)
}
mintCountPerWallet[_msgSender()] += quantity;
supply += quantity;
_safeMint(_msgSender(), quantity);
_refundIfOver(mintPrice * quantity);
}
/**===========================================================================
Setter Functions
============================================================================== */
function setTotalQuantity(uint256 quantity) external onlyOwner {
}
function setMaxMint(uint256 maxMint) external onlyOwner {
}
function setMaxMintTx(uint256 maxMintTx) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setStartTime(uint256 startTime) external onlyOwner {
}
function setEndTime(uint256 endTime) external onlyOwner {
}
}
| mintCountPerWallet[_msgSender()]+quantity<=maxMintPerWallet,"Exceeds mints allowed per wallet" | 453,062 | mintCountPerWallet[_msgSender()]+quantity<=maxMintPerWallet |
"PaymentSplitter: account has no shares" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "contracts/utils/oz-presets/PrimarySaleSplitter.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "../interfaces/IMMFee.sol";
abstract contract PrimarySale is
OwnableUpgradeable,
ReentrancyGuardUpgradeable,
PrimarySaleSplitter
{
// Max bps in the magicmynt system
uint128 private constant MAX_BPS = 10_000;
// Magic Mynt contract with fee related information
IMMFee internal platformFee;
function __PrimarySale_init(
address _mmFee,
address[] memory payees,
uint256[] memory shares
) internal onlyInitializing {
}
/***********************************************************************
CONTRACT METADATA
*************************************************************************/
function platformFeeInfo() public view returns (address, uint256) {
}
function withdraw() public virtual onlyOwner nonReentrant {
}
function release(address payable account) public virtual override {
}
function _release(address payable account) internal returns (uint256) {
require(<FILL_ME>)
uint256 totalReceived = address(this).balance + totalReleased();
uint256 payment = _pendingPayment(
account,
totalReceived,
released(account)
);
if (payment == 0) {
return 0;
}
_released[account] += payment;
_totalReleased += payment;
// platform fees
uint256 fee = 0;
(address feeRecipient, uint256 feeBps) = platformFee.getFeeInfo();
if (feeRecipient != address(0) && feeBps > 0) {
fee = (payment * feeBps) / MAX_BPS;
AddressUpgradeable.sendValue(payable(feeRecipient), fee);
}
AddressUpgradeable.sendValue(account, payment - fee);
emit PaymentReleased(account, payment);
return payment;
}
}
| shares(account)>0,"PaymentSplitter: account has no shares" | 453,066 | shares(account)>0 |
"Can not set buy fees higher than 6" | //SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
pragma solidity ^0.8.17;
interface DexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface DexRouter {
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;
}
contract FitPepe is ERC20, Ownable {
struct Tax {
uint256 marketingTax;
uint256 buybackTax;
}
uint256 private constant _totalSupply = 1_000_000_000_000 * 1e18;
//Router
DexRouter public immutable uniswapRouter;
address public immutable pairAddress;
//Taxes
Tax public buyTaxes = Tax(3, 0);
Tax public sellTaxes = Tax(2, 1);
uint256 public totalBuyFees = 3;
uint256 public totalSellFees = 3;
//Whitelisting from taxes/maxwallet/txlimit/etc
mapping(address => bool) private whitelisted;
//Swapping
uint256 public swapTokensAtAmount = _totalSupply / 10000; //after 0.001% of total supply, swap them
bool public swapAndLiquifyEnabled = true;
bool public isSwapping = false;
//Wallets
address public marketingWallet = 0x7bA6E2fF8888BF229E7A70C1DC519BeE5612d0Fb;
address public buybackWallet = 0x0d32047C93116ad5684B8Dae76cdaA89b97831A8;
//Events
event marketingWalletChanged(address indexed _trWallet);
event BuyFeesUpdated(uint256 indexed _trFee);
event SellFeesUpdated(uint256 indexed _trFee);
event TransferFeesUpdated(uint256 indexed _trFee);
event SwapThresholdUpdated(uint256 indexed _newThreshold);
event InternalSwapStatusUpdated(bool indexed _status);
event Whitelist(address indexed _target, bool indexed _status);
constructor() ERC20("FitPepe", "FitP") {
}
function setMrketingWallet(address _newMarketing) external onlyOwner {
}
function setBuyBackWallet(address _newBuyBack) external onlyOwner {
}
function setBuyTaxes(uint256 _marketingTax, uint256 _buybackTax) external onlyOwner {
buyTaxes.marketingTax = _marketingTax;
buyTaxes.buybackTax = _buybackTax;
totalBuyFees = _marketingTax + _buybackTax;
require(<FILL_ME>)
}
function setSellTaxes(uint256 _marketingTax, uint256 _buybackTax) external onlyOwner {
}
function setSwapTokensAtAmount(uint256 _newAmount) external onlyOwner {
}
function toggleSwapping() external onlyOwner {
}
function setWhitelistStatus(address _wallet, bool _status) external onlyOwner {
}
function checkWhitelist(address _wallet) external view returns (bool) {
}
// this function is reponsible for managing tax, if _from or _to is whitelisted, we simply return _amount and skip all the limitations
function _takeTax(address _from, address _to, uint256 _amount) internal returns (uint256) {
}
function _transfer(address _from, address _to, uint256 _amount) internal virtual override {
}
function internalSwap() internal {
}
function swapToETH(uint256 _amount) internal {
}
function withdrawStuckETH() external onlyOwner {
}
function withdrawStuckTokens(address BEP20_token) external onlyOwner {
}
receive() external payable {}
}
| _marketingTax+_buybackTax<=6,"Can not set buy fees higher than 6" | 453,577 | _marketingTax+_buybackTax<=6 |
"Can not set buy fees higher than 6%" | //SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
pragma solidity ^0.8.17;
interface DexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface DexRouter {
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;
}
contract FitPepe is ERC20, Ownable {
struct Tax {
uint256 marketingTax;
uint256 buybackTax;
}
uint256 private constant _totalSupply = 1_000_000_000_000 * 1e18;
//Router
DexRouter public immutable uniswapRouter;
address public immutable pairAddress;
//Taxes
Tax public buyTaxes = Tax(3, 0);
Tax public sellTaxes = Tax(2, 1);
uint256 public totalBuyFees = 3;
uint256 public totalSellFees = 3;
//Whitelisting from taxes/maxwallet/txlimit/etc
mapping(address => bool) private whitelisted;
//Swapping
uint256 public swapTokensAtAmount = _totalSupply / 10000; //after 0.001% of total supply, swap them
bool public swapAndLiquifyEnabled = true;
bool public isSwapping = false;
//Wallets
address public marketingWallet = 0x7bA6E2fF8888BF229E7A70C1DC519BeE5612d0Fb;
address public buybackWallet = 0x0d32047C93116ad5684B8Dae76cdaA89b97831A8;
//Events
event marketingWalletChanged(address indexed _trWallet);
event BuyFeesUpdated(uint256 indexed _trFee);
event SellFeesUpdated(uint256 indexed _trFee);
event TransferFeesUpdated(uint256 indexed _trFee);
event SwapThresholdUpdated(uint256 indexed _newThreshold);
event InternalSwapStatusUpdated(bool indexed _status);
event Whitelist(address indexed _target, bool indexed _status);
constructor() ERC20("FitPepe", "FitP") {
}
function setMrketingWallet(address _newMarketing) external onlyOwner {
}
function setBuyBackWallet(address _newBuyBack) external onlyOwner {
}
function setBuyTaxes(uint256 _marketingTax, uint256 _buybackTax) external onlyOwner {
}
function setSellTaxes(uint256 _marketingTax, uint256 _buybackTax) external onlyOwner {
sellTaxes.marketingTax = _marketingTax;
sellTaxes.buybackTax = _buybackTax;
totalSellFees = _marketingTax + _buybackTax;
require(<FILL_ME>)
}
function setSwapTokensAtAmount(uint256 _newAmount) external onlyOwner {
}
function toggleSwapping() external onlyOwner {
}
function setWhitelistStatus(address _wallet, bool _status) external onlyOwner {
}
function checkWhitelist(address _wallet) external view returns (bool) {
}
// this function is reponsible for managing tax, if _from or _to is whitelisted, we simply return _amount and skip all the limitations
function _takeTax(address _from, address _to, uint256 _amount) internal returns (uint256) {
}
function _transfer(address _from, address _to, uint256 _amount) internal virtual override {
}
function internalSwap() internal {
}
function swapToETH(uint256 _amount) internal {
}
function withdrawStuckETH() external onlyOwner {
}
function withdrawStuckTokens(address BEP20_token) external onlyOwner {
}
receive() external payable {}
}
| _marketingTax+_buybackTax<=8,"Can not set buy fees higher than 6%" | 453,577 | _marketingTax+_buybackTax<=8 |
"LOWER_THAN_RESERVED" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./ERC721AMinterExtension.sol";
import {IERC721TieringExtension} from "../../ERC721/extensions/ERC721TieringExtension.sol";
/**
* @dev Extension to allow multiple tiers for minting,
* you can configure, different minting window, price, currency, max per wallet, and allowlist per tier.
*/
abstract contract ERC721ATieringExtension is
IERC721TieringExtension,
Initializable,
Ownable,
ERC721AMinterExtension,
ReentrancyGuard
{
mapping(uint256 => Tier) public tiers;
uint256 public totalReserved;
mapping(uint256 => uint256) public tierMints;
mapping(uint256 => mapping(address => uint256)) internal walletMinted;
uint256 public reservedMints;
function __ERC721ATieringExtension_init(Tier[] memory _tiers)
internal
onlyInitializing
{
}
function __ERC721ATieringExtension_init_unchained(Tier[] memory _tiers)
internal
onlyInitializing
{
}
/* ADMIN */
function configureTiering(uint256 tierId, Tier calldata tier)
public
onlyOwner
{
}
function configureTiering(
uint256[] calldata _tierIds,
Tier[] calldata _tiers
) public onlyOwner {
}
/* PUBLIC */
function setMaxSupply(uint256 newValue)
public
virtual
override(ERC721AMinterExtension)
onlyOwner
{
ERC721AMinterExtension.setMaxSupply(newValue);
require(<FILL_ME>)
}
function onTierAllowlist(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (bool) {
}
function eligibleForTier(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (uint256 maxMintable) {
}
function mintByTier(
uint256 tierId,
uint256 count,
uint256 maxAllowance,
bytes32[] calldata proof
) external payable nonReentrant {
}
function remainingForTier(uint256 tierId)
public
view
returns (uint256 tierRemaining)
{
}
function walletMintedByTier(uint256 tierId, address wallet)
public
view
returns (uint256)
{
}
/* PRIVATE */
function _generateMerkleLeaf(address account, uint256 maxAllowance)
private
pure
returns (bytes32)
{
}
}
| newValue-totalSupply()>=totalReserved-reservedMints,"LOWER_THAN_RESERVED" | 453,606 | newValue-totalSupply()>=totalReserved-reservedMints |
"NOT_EXISTS" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./ERC721AMinterExtension.sol";
import {IERC721TieringExtension} from "../../ERC721/extensions/ERC721TieringExtension.sol";
/**
* @dev Extension to allow multiple tiers for minting,
* you can configure, different minting window, price, currency, max per wallet, and allowlist per tier.
*/
abstract contract ERC721ATieringExtension is
IERC721TieringExtension,
Initializable,
Ownable,
ERC721AMinterExtension,
ReentrancyGuard
{
mapping(uint256 => Tier) public tiers;
uint256 public totalReserved;
mapping(uint256 => uint256) public tierMints;
mapping(uint256 => mapping(address => uint256)) internal walletMinted;
uint256 public reservedMints;
function __ERC721ATieringExtension_init(Tier[] memory _tiers)
internal
onlyInitializing
{
}
function __ERC721ATieringExtension_init_unchained(Tier[] memory _tiers)
internal
onlyInitializing
{
}
/* ADMIN */
function configureTiering(uint256 tierId, Tier calldata tier)
public
onlyOwner
{
}
function configureTiering(
uint256[] calldata _tierIds,
Tier[] calldata _tiers
) public onlyOwner {
}
/* PUBLIC */
function setMaxSupply(uint256 newValue)
public
virtual
override(ERC721AMinterExtension)
onlyOwner
{
}
function onTierAllowlist(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (bool) {
}
function eligibleForTier(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (uint256 maxMintable) {
require(<FILL_ME>)
require(block.timestamp >= tiers[tierId].start, "NOT_STARTED");
require(block.timestamp <= tiers[tierId].end, "ALREADY_ENDED");
maxMintable = tiers[tierId].maxPerWallet - walletMinted[tierId][minter];
if (tiers[tierId].merkleRoot != bytes32(0)) {
require(
walletMinted[tierId][minter] < maxAllowance,
"MAXED_ALLOWANCE"
);
require(
onTierAllowlist(tierId, minter, maxAllowance, proof),
"NOT_ALLOWLISTED"
);
uint256 remainingAllowance = maxAllowance -
walletMinted[tierId][minter];
if (maxMintable > remainingAllowance) {
maxMintable = remainingAllowance;
}
}
}
function mintByTier(
uint256 tierId,
uint256 count,
uint256 maxAllowance,
bytes32[] calldata proof
) external payable nonReentrant {
}
function remainingForTier(uint256 tierId)
public
view
returns (uint256 tierRemaining)
{
}
function walletMintedByTier(uint256 tierId, address wallet)
public
view
returns (uint256)
{
}
/* PRIVATE */
function _generateMerkleLeaf(address account, uint256 maxAllowance)
private
pure
returns (bytes32)
{
}
}
| tiers[tierId].maxPerWallet>0,"NOT_EXISTS" | 453,606 | tiers[tierId].maxPerWallet>0 |
"MAXED_ALLOWANCE" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./ERC721AMinterExtension.sol";
import {IERC721TieringExtension} from "../../ERC721/extensions/ERC721TieringExtension.sol";
/**
* @dev Extension to allow multiple tiers for minting,
* you can configure, different minting window, price, currency, max per wallet, and allowlist per tier.
*/
abstract contract ERC721ATieringExtension is
IERC721TieringExtension,
Initializable,
Ownable,
ERC721AMinterExtension,
ReentrancyGuard
{
mapping(uint256 => Tier) public tiers;
uint256 public totalReserved;
mapping(uint256 => uint256) public tierMints;
mapping(uint256 => mapping(address => uint256)) internal walletMinted;
uint256 public reservedMints;
function __ERC721ATieringExtension_init(Tier[] memory _tiers)
internal
onlyInitializing
{
}
function __ERC721ATieringExtension_init_unchained(Tier[] memory _tiers)
internal
onlyInitializing
{
}
/* ADMIN */
function configureTiering(uint256 tierId, Tier calldata tier)
public
onlyOwner
{
}
function configureTiering(
uint256[] calldata _tierIds,
Tier[] calldata _tiers
) public onlyOwner {
}
/* PUBLIC */
function setMaxSupply(uint256 newValue)
public
virtual
override(ERC721AMinterExtension)
onlyOwner
{
}
function onTierAllowlist(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (bool) {
}
function eligibleForTier(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (uint256 maxMintable) {
require(tiers[tierId].maxPerWallet > 0, "NOT_EXISTS");
require(block.timestamp >= tiers[tierId].start, "NOT_STARTED");
require(block.timestamp <= tiers[tierId].end, "ALREADY_ENDED");
maxMintable = tiers[tierId].maxPerWallet - walletMinted[tierId][minter];
if (tiers[tierId].merkleRoot != bytes32(0)) {
require(<FILL_ME>)
require(
onTierAllowlist(tierId, minter, maxAllowance, proof),
"NOT_ALLOWLISTED"
);
uint256 remainingAllowance = maxAllowance -
walletMinted[tierId][minter];
if (maxMintable > remainingAllowance) {
maxMintable = remainingAllowance;
}
}
}
function mintByTier(
uint256 tierId,
uint256 count,
uint256 maxAllowance,
bytes32[] calldata proof
) external payable nonReentrant {
}
function remainingForTier(uint256 tierId)
public
view
returns (uint256 tierRemaining)
{
}
function walletMintedByTier(uint256 tierId, address wallet)
public
view
returns (uint256)
{
}
/* PRIVATE */
function _generateMerkleLeaf(address account, uint256 maxAllowance)
private
pure
returns (bytes32)
{
}
}
| walletMinted[tierId][minter]<maxAllowance,"MAXED_ALLOWANCE" | 453,606 | walletMinted[tierId][minter]<maxAllowance |
"NOT_ALLOWLISTED" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./ERC721AMinterExtension.sol";
import {IERC721TieringExtension} from "../../ERC721/extensions/ERC721TieringExtension.sol";
/**
* @dev Extension to allow multiple tiers for minting,
* you can configure, different minting window, price, currency, max per wallet, and allowlist per tier.
*/
abstract contract ERC721ATieringExtension is
IERC721TieringExtension,
Initializable,
Ownable,
ERC721AMinterExtension,
ReentrancyGuard
{
mapping(uint256 => Tier) public tiers;
uint256 public totalReserved;
mapping(uint256 => uint256) public tierMints;
mapping(uint256 => mapping(address => uint256)) internal walletMinted;
uint256 public reservedMints;
function __ERC721ATieringExtension_init(Tier[] memory _tiers)
internal
onlyInitializing
{
}
function __ERC721ATieringExtension_init_unchained(Tier[] memory _tiers)
internal
onlyInitializing
{
}
/* ADMIN */
function configureTiering(uint256 tierId, Tier calldata tier)
public
onlyOwner
{
}
function configureTiering(
uint256[] calldata _tierIds,
Tier[] calldata _tiers
) public onlyOwner {
}
/* PUBLIC */
function setMaxSupply(uint256 newValue)
public
virtual
override(ERC721AMinterExtension)
onlyOwner
{
}
function onTierAllowlist(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (bool) {
}
function eligibleForTier(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (uint256 maxMintable) {
require(tiers[tierId].maxPerWallet > 0, "NOT_EXISTS");
require(block.timestamp >= tiers[tierId].start, "NOT_STARTED");
require(block.timestamp <= tiers[tierId].end, "ALREADY_ENDED");
maxMintable = tiers[tierId].maxPerWallet - walletMinted[tierId][minter];
if (tiers[tierId].merkleRoot != bytes32(0)) {
require(
walletMinted[tierId][minter] < maxAllowance,
"MAXED_ALLOWANCE"
);
require(<FILL_ME>)
uint256 remainingAllowance = maxAllowance -
walletMinted[tierId][minter];
if (maxMintable > remainingAllowance) {
maxMintable = remainingAllowance;
}
}
}
function mintByTier(
uint256 tierId,
uint256 count,
uint256 maxAllowance,
bytes32[] calldata proof
) external payable nonReentrant {
}
function remainingForTier(uint256 tierId)
public
view
returns (uint256 tierRemaining)
{
}
function walletMintedByTier(uint256 tierId, address wallet)
public
view
returns (uint256)
{
}
/* PRIVATE */
function _generateMerkleLeaf(address account, uint256 maxAllowance)
private
pure
returns (bytes32)
{
}
}
| onTierAllowlist(tierId,minter,maxAllowance,proof),"NOT_ALLOWLISTED" | 453,606 | onTierAllowlist(tierId,minter,maxAllowance,proof) |
"EXCEEDS_ALLOCATION" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./ERC721AMinterExtension.sol";
import {IERC721TieringExtension} from "../../ERC721/extensions/ERC721TieringExtension.sol";
/**
* @dev Extension to allow multiple tiers for minting,
* you can configure, different minting window, price, currency, max per wallet, and allowlist per tier.
*/
abstract contract ERC721ATieringExtension is
IERC721TieringExtension,
Initializable,
Ownable,
ERC721AMinterExtension,
ReentrancyGuard
{
mapping(uint256 => Tier) public tiers;
uint256 public totalReserved;
mapping(uint256 => uint256) public tierMints;
mapping(uint256 => mapping(address => uint256)) internal walletMinted;
uint256 public reservedMints;
function __ERC721ATieringExtension_init(Tier[] memory _tiers)
internal
onlyInitializing
{
}
function __ERC721ATieringExtension_init_unchained(Tier[] memory _tiers)
internal
onlyInitializing
{
}
/* ADMIN */
function configureTiering(uint256 tierId, Tier calldata tier)
public
onlyOwner
{
}
function configureTiering(
uint256[] calldata _tierIds,
Tier[] calldata _tiers
) public onlyOwner {
}
/* PUBLIC */
function setMaxSupply(uint256 newValue)
public
virtual
override(ERC721AMinterExtension)
onlyOwner
{
}
function onTierAllowlist(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (bool) {
}
function eligibleForTier(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (uint256 maxMintable) {
}
function mintByTier(
uint256 tierId,
uint256 count,
uint256 maxAllowance,
bytes32[] calldata proof
) external payable nonReentrant {
address minter = _msgSender();
uint256 maxMintable = eligibleForTier(
tierId,
minter,
maxAllowance,
proof
);
require(count <= maxMintable, "EXCEEDS_MAX");
require(count <= remainingForTier(tierId), "EXCEEDS_ALLOCATION");
require(<FILL_ME>)
if (tiers[tierId].currency == address(0)) {
require(
tiers[tierId].price * count <= msg.value,
"INSUFFICIENT_AMOUNT"
);
} else {
IERC20(tiers[tierId].currency).transferFrom(
minter,
address(this),
tiers[tierId].price * count
);
}
walletMinted[tierId][minter] += count;
tierMints[tierId] += count;
if (tiers[tierId].reserved > 0) {
reservedMints += count;
}
_mintTo(minter, count);
}
function remainingForTier(uint256 tierId)
public
view
returns (uint256 tierRemaining)
{
}
function walletMintedByTier(uint256 tierId, address wallet)
public
view
returns (uint256)
{
}
/* PRIVATE */
function _generateMerkleLeaf(address account, uint256 maxAllowance)
private
pure
returns (bytes32)
{
}
}
| count+tierMints[tierId]<=tiers[tierId].maxAllocation,"EXCEEDS_ALLOCATION" | 453,606 | count+tierMints[tierId]<=tiers[tierId].maxAllocation |
"INSUFFICIENT_AMOUNT" | // SPDX-License-Identifier: AGPL-3.0
pragma solidity 0.8.9;
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./ERC721AMinterExtension.sol";
import {IERC721TieringExtension} from "../../ERC721/extensions/ERC721TieringExtension.sol";
/**
* @dev Extension to allow multiple tiers for minting,
* you can configure, different minting window, price, currency, max per wallet, and allowlist per tier.
*/
abstract contract ERC721ATieringExtension is
IERC721TieringExtension,
Initializable,
Ownable,
ERC721AMinterExtension,
ReentrancyGuard
{
mapping(uint256 => Tier) public tiers;
uint256 public totalReserved;
mapping(uint256 => uint256) public tierMints;
mapping(uint256 => mapping(address => uint256)) internal walletMinted;
uint256 public reservedMints;
function __ERC721ATieringExtension_init(Tier[] memory _tiers)
internal
onlyInitializing
{
}
function __ERC721ATieringExtension_init_unchained(Tier[] memory _tiers)
internal
onlyInitializing
{
}
/* ADMIN */
function configureTiering(uint256 tierId, Tier calldata tier)
public
onlyOwner
{
}
function configureTiering(
uint256[] calldata _tierIds,
Tier[] calldata _tiers
) public onlyOwner {
}
/* PUBLIC */
function setMaxSupply(uint256 newValue)
public
virtual
override(ERC721AMinterExtension)
onlyOwner
{
}
function onTierAllowlist(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (bool) {
}
function eligibleForTier(
uint256 tierId,
address minter,
uint256 maxAllowance,
bytes32[] calldata proof
) public view returns (uint256 maxMintable) {
}
function mintByTier(
uint256 tierId,
uint256 count,
uint256 maxAllowance,
bytes32[] calldata proof
) external payable nonReentrant {
address minter = _msgSender();
uint256 maxMintable = eligibleForTier(
tierId,
minter,
maxAllowance,
proof
);
require(count <= maxMintable, "EXCEEDS_MAX");
require(count <= remainingForTier(tierId), "EXCEEDS_ALLOCATION");
require(
count + tierMints[tierId] <= tiers[tierId].maxAllocation,
"EXCEEDS_ALLOCATION"
);
if (tiers[tierId].currency == address(0)) {
require(<FILL_ME>)
} else {
IERC20(tiers[tierId].currency).transferFrom(
minter,
address(this),
tiers[tierId].price * count
);
}
walletMinted[tierId][minter] += count;
tierMints[tierId] += count;
if (tiers[tierId].reserved > 0) {
reservedMints += count;
}
_mintTo(minter, count);
}
function remainingForTier(uint256 tierId)
public
view
returns (uint256 tierRemaining)
{
}
function walletMintedByTier(uint256 tierId, address wallet)
public
view
returns (uint256)
{
}
/* PRIVATE */
function _generateMerkleLeaf(address account, uint256 maxAllowance)
private
pure
returns (bytes32)
{
}
}
| tiers[tierId].price*count<=msg.value,"INSUFFICIENT_AMOUNT" | 453,606 | tiers[tierId].price*count<=msg.value |
"NFT already minted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract Titano is ERC721, ERC721URIStorage, Ownable {
mapping(string => uint8) existingURIs;
constructor() ERC721("Titano", "titano") {}
function payToMint(
address wallet,
uint256 tokenId,
string memory metadata
) public payable {
require(<FILL_ME>)
require(msg.value >= 0.02 ether, "Need to pay up!");
_safeMint(wallet, tokenId);
_setTokenURI(tokenId, metadata);
existingURIs[metadata] = 1;
withdraw();
}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function withdraw() public returns (bool) {
}
}
| existingURIs[metadata]!=1,"NFT already minted!" | 453,683 | existingURIs[metadata]!=1 |
'exceeds period limit' | pragma solidity 0.8.4;
contract Pool is Ownable, ReentrancyGuard, Initializable, IPool {
using SafeERC20 for ERC20;
/* ========== ADDRESSES ================ */
address public oracle;
address public collateral;
address public dollar;
address public treasury;
address public share;
/* ========== STATE VARIABLES ========== */
mapping(address => uint256) public redeem_share_balances;
mapping(address => uint256) public redeem_collateral_balances;
uint256 public override unclaimed_pool_collateral;
uint256 public unclaimed_pool_share;
uint256 public netDollarMinted;
mapping(address => uint256) public last_redeemed;
// Constants for various precisions
uint256 private constant PRICE_PRECISION = 1e6;
uint256 private constant COLLATERAL_RATIO_PRECISION = 1e6;
uint256 private constant COLLATERAL_RATIO_MAX = 1e6;
// Number of decimals needed to get to 18
uint256 private missing_decimals;
// Number of blocks to wait before being able to collectRedemption()
uint256 public redemption_delay = 1;
// AccessControl state variables
bool public mint_paused = false;
bool public redeem_paused = false;
uint256 public period; // how many seconds before limit resets
uint256 public mintLimit; // max amount per period
uint256 public redeemLimit; // max amount per period
uint256 public currentPeriodEnd; // timestamp which the current period ends at
uint256 public currentPeriodMintAmount; // amount already minted this period
uint256 public currentPeriodRedeemAmount; // amount already redeemed this period
/* ========== MODIFIERS ========== */
modifier onlyTreasury() {
}
/* ========== CONSTRUCTOR ========== */
function initialize(
address _dollar,
address _share,
address _collateral,
address _treasury,
uint256 _period,
uint256 _mintLimit,
uint256 _redeemLimit
) external initializer onlyOwner {
}
/* ========== VIEWS ========== */
function info()
external
view
returns (
uint256,
uint256,
uint256,
bool,
bool
)
{
}
function collateralReserve() public view returns (address) {
}
function getCollateralPrice() public view override returns (uint256) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function mint(
uint256 _collateral_amount,
uint256 _share_amount,
uint256 _dollar_out_min
) external {
require(mint_paused == false, "Minting is paused");
(, uint256 _share_price, , uint256 _tcr, , , uint256 _minting_fee, ) =
ITreasury(treasury).info();
require(_share_price > 0, "Invalid share price");
uint256 _price_collateral = getCollateralPrice();
uint256 _total_dollar_value = 0;
uint256 _required_share_amount = 0;
// dollar value = collateral value / tcr
// assumes dollar is always $1
if (_tcr > 0) {
uint256 _collateral_value =
((_collateral_amount * (10**missing_decimals)) * _price_collateral) /
PRICE_PRECISION;
_total_dollar_value = (_collateral_value * COLLATERAL_RATIO_PRECISION) / _tcr;
if (_tcr < COLLATERAL_RATIO_MAX) {
_required_share_amount =
((_total_dollar_value - _collateral_value) * PRICE_PRECISION) /
_share_price;
}
} else {
_total_dollar_value = (_share_amount * _share_price) / PRICE_PRECISION;
_required_share_amount = _share_amount;
}
// reduces dollar output by minting fee
uint256 _actual_dollar_amount =
_total_dollar_value - ((_total_dollar_value * _minting_fee) / PRICE_PRECISION);
require(_dollar_out_min <= _actual_dollar_amount, "slippage");
if (_required_share_amount > 0) {
require(_required_share_amount <= _share_amount, "Not enough SHARE input");
IShare(share).poolBurnFrom(msg.sender, _required_share_amount); // burns the user's share tokens
}
if (_collateral_amount > 0) {
_transferCollateralToReserve(msg.sender, _collateral_amount);
}
IDollar(dollar).poolMint(msg.sender, _actual_dollar_amount);
netDollarMinted = netDollarMinted + _actual_dollar_amount;
// Update period before proceeding
updatePeriod();
// Prevent overflow
uint totalAmount = currentPeriodMintAmount + _actual_dollar_amount;
require(totalAmount >= currentPeriodMintAmount, 'overflow');
// Disallow mints that exceed current rate limit
require(<FILL_ME>)
currentPeriodMintAmount += _actual_dollar_amount;
}
function redeem(
uint256 _dollar_amount,
uint256 _share_out_min,
uint256 _collateral_out_min
) external {
}
function getNetDollarMinted() public view returns (uint256) {
}
function collectRedemption() external {
}
function updatePeriod() internal {
}
/* ========== INTERNAL FUNCTIONS ========== */
function _transferCollateralToReserve(address _sender, uint256 _amount) internal {
}
function _mintShareToCollateralReserve(uint256 _amount) internal {
}
function _requestTransferCollateral(address _receiver, uint256 _amount) internal {
}
function _requestTransferShare(address _receiver, uint256 _amount) internal {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function toggleMinting() external onlyOwner {
}
function toggleRedeeming() external onlyOwner {
}
function setOracle(address _oracle) external onlyOwner {
}
function setRedemptionDelay(uint256 _redemption_delay) external onlyOwner {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setPeriod(uint256 _period) external onlyOwner {
}
function setMintLimit(uint256 _mintLimit) external onlyOwner {
}
function setRedeemLimit(uint256 _redeemLimit) external onlyOwner {
}
// EVENTS
event TreasuryChanged(address indexed newTreasury);
}
| currentPeriodMintAmount+_actual_dollar_amount<mintLimit,'exceeds period limit' | 453,763 | currentPeriodMintAmount+_actual_dollar_amount<mintLimit |
'exceeds period limit' | pragma solidity 0.8.4;
contract Pool is Ownable, ReentrancyGuard, Initializable, IPool {
using SafeERC20 for ERC20;
/* ========== ADDRESSES ================ */
address public oracle;
address public collateral;
address public dollar;
address public treasury;
address public share;
/* ========== STATE VARIABLES ========== */
mapping(address => uint256) public redeem_share_balances;
mapping(address => uint256) public redeem_collateral_balances;
uint256 public override unclaimed_pool_collateral;
uint256 public unclaimed_pool_share;
uint256 public netDollarMinted;
mapping(address => uint256) public last_redeemed;
// Constants for various precisions
uint256 private constant PRICE_PRECISION = 1e6;
uint256 private constant COLLATERAL_RATIO_PRECISION = 1e6;
uint256 private constant COLLATERAL_RATIO_MAX = 1e6;
// Number of decimals needed to get to 18
uint256 private missing_decimals;
// Number of blocks to wait before being able to collectRedemption()
uint256 public redemption_delay = 1;
// AccessControl state variables
bool public mint_paused = false;
bool public redeem_paused = false;
uint256 public period; // how many seconds before limit resets
uint256 public mintLimit; // max amount per period
uint256 public redeemLimit; // max amount per period
uint256 public currentPeriodEnd; // timestamp which the current period ends at
uint256 public currentPeriodMintAmount; // amount already minted this period
uint256 public currentPeriodRedeemAmount; // amount already redeemed this period
/* ========== MODIFIERS ========== */
modifier onlyTreasury() {
}
/* ========== CONSTRUCTOR ========== */
function initialize(
address _dollar,
address _share,
address _collateral,
address _treasury,
uint256 _period,
uint256 _mintLimit,
uint256 _redeemLimit
) external initializer onlyOwner {
}
/* ========== VIEWS ========== */
function info()
external
view
returns (
uint256,
uint256,
uint256,
bool,
bool
)
{
}
function collateralReserve() public view returns (address) {
}
function getCollateralPrice() public view override returns (uint256) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function mint(
uint256 _collateral_amount,
uint256 _share_amount,
uint256 _dollar_out_min
) external {
}
function redeem(
uint256 _dollar_amount,
uint256 _share_out_min,
uint256 _collateral_out_min
) external {
require(redeem_paused == false, "Redeeming is paused");
// Update period before proceeding
updatePeriod();
// Prevent overflow
uint totalAmount = currentPeriodRedeemAmount + _dollar_amount;
require(totalAmount >= currentPeriodRedeemAmount, 'overflow');
// Disallow mints that exceed current rate limit
require(<FILL_ME>)
currentPeriodRedeemAmount += _dollar_amount;
(, uint256 _share_price, , , uint256 _ecr, , , uint256 _redemption_fee) =
ITreasury(treasury).info();
uint256 _collateral_price = getCollateralPrice();
require(_collateral_price > 0, "Invalid collateral price");
require(_share_price > 0, "Invalid share price");
uint256 _dollar_amount_post_fee =
_dollar_amount - ((_dollar_amount * _redemption_fee) / PRICE_PRECISION);
uint256 _collateral_output_amount = 0;
uint256 _share_output_amount = 0;
// number of shares to mint to user
if (_ecr < COLLATERAL_RATIO_MAX) {
uint256 _share_output_value =
_dollar_amount_post_fee - ((_dollar_amount_post_fee * _ecr) / PRICE_PRECISION);
_share_output_amount = (_share_output_value * PRICE_PRECISION) / _share_price;
}
// amount of collateral tokens to transfer to the user from the CollateralReserve
if (_ecr > 0) {
uint256 _collateral_output_value =
((_dollar_amount_post_fee * _ecr) / PRICE_PRECISION) / (10**missing_decimals);
_collateral_output_amount =
(_collateral_output_value * PRICE_PRECISION) /
_collateral_price;
}
// Check if collateral balance is within the global collateral balance
uint256 _totalCollateralBalance = ITreasury(treasury).globalCollateralBalance();
require(_collateral_output_amount <= _totalCollateralBalance, "<collateralBalance");
// the amount of collateral and shares you're going to get should be greater or equal to what you were expecting
require(
_collateral_out_min <= _collateral_output_amount &&
_share_out_min <= _share_output_amount,
">slippage"
);
// 1. keep track of collateral owed to the user
// 2. add the claimable amount to unclaimed_pool_collateral for informational purposes
if (_collateral_output_amount > 0) {
redeem_collateral_balances[msg.sender] =
redeem_collateral_balances[msg.sender] +
_collateral_output_amount;
unclaimed_pool_collateral = unclaimed_pool_collateral + _collateral_output_amount;
}
// 1. keep track of shares owed to the user
// 2. add the claimable amount to unclaimed_pool_share for informational purposes
if (_share_output_amount > 0) {
redeem_share_balances[msg.sender] =
redeem_share_balances[msg.sender] +
_share_output_amount;
unclaimed_pool_share = unclaimed_pool_share + _share_output_amount;
}
// keep track of when this function was called for this user (so that it can wait x blocks for them to redeem the amounts)
last_redeemed[msg.sender] = block.number;
// Move all external functions to the end
// burns the user's dollar token
IDollar(dollar).poolBurnFrom(msg.sender, _dollar_amount);
if (_share_output_amount > 0) {
// mints the amount of shares that will be collected in the next step
_mintShareToCollateralReserve(_share_output_amount);
}
if (_dollar_amount > netDollarMinted) {
netDollarMinted = 0;
} else {
// Prevent overflow
uint newNetAmount = netDollarMinted - _dollar_amount;
require(newNetAmount <= netDollarMinted, 'overflow');
netDollarMinted = netDollarMinted - _dollar_amount;
}
}
function getNetDollarMinted() public view returns (uint256) {
}
function collectRedemption() external {
}
function updatePeriod() internal {
}
/* ========== INTERNAL FUNCTIONS ========== */
function _transferCollateralToReserve(address _sender, uint256 _amount) internal {
}
function _mintShareToCollateralReserve(uint256 _amount) internal {
}
function _requestTransferCollateral(address _receiver, uint256 _amount) internal {
}
function _requestTransferShare(address _receiver, uint256 _amount) internal {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function toggleMinting() external onlyOwner {
}
function toggleRedeeming() external onlyOwner {
}
function setOracle(address _oracle) external onlyOwner {
}
function setRedemptionDelay(uint256 _redemption_delay) external onlyOwner {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setPeriod(uint256 _period) external onlyOwner {
}
function setMintLimit(uint256 _mintLimit) external onlyOwner {
}
function setRedeemLimit(uint256 _redeemLimit) external onlyOwner {
}
// EVENTS
event TreasuryChanged(address indexed newTreasury);
}
| currentPeriodRedeemAmount+_dollar_amount<redeemLimit,'exceeds period limit' | 453,763 | currentPeriodRedeemAmount+_dollar_amount<redeemLimit |
"<redemption_delay" | pragma solidity 0.8.4;
contract Pool is Ownable, ReentrancyGuard, Initializable, IPool {
using SafeERC20 for ERC20;
/* ========== ADDRESSES ================ */
address public oracle;
address public collateral;
address public dollar;
address public treasury;
address public share;
/* ========== STATE VARIABLES ========== */
mapping(address => uint256) public redeem_share_balances;
mapping(address => uint256) public redeem_collateral_balances;
uint256 public override unclaimed_pool_collateral;
uint256 public unclaimed_pool_share;
uint256 public netDollarMinted;
mapping(address => uint256) public last_redeemed;
// Constants for various precisions
uint256 private constant PRICE_PRECISION = 1e6;
uint256 private constant COLLATERAL_RATIO_PRECISION = 1e6;
uint256 private constant COLLATERAL_RATIO_MAX = 1e6;
// Number of decimals needed to get to 18
uint256 private missing_decimals;
// Number of blocks to wait before being able to collectRedemption()
uint256 public redemption_delay = 1;
// AccessControl state variables
bool public mint_paused = false;
bool public redeem_paused = false;
uint256 public period; // how many seconds before limit resets
uint256 public mintLimit; // max amount per period
uint256 public redeemLimit; // max amount per period
uint256 public currentPeriodEnd; // timestamp which the current period ends at
uint256 public currentPeriodMintAmount; // amount already minted this period
uint256 public currentPeriodRedeemAmount; // amount already redeemed this period
/* ========== MODIFIERS ========== */
modifier onlyTreasury() {
}
/* ========== CONSTRUCTOR ========== */
function initialize(
address _dollar,
address _share,
address _collateral,
address _treasury,
uint256 _period,
uint256 _mintLimit,
uint256 _redeemLimit
) external initializer onlyOwner {
}
/* ========== VIEWS ========== */
function info()
external
view
returns (
uint256,
uint256,
uint256,
bool,
bool
)
{
}
function collateralReserve() public view returns (address) {
}
function getCollateralPrice() public view override returns (uint256) {
}
/* ========== PUBLIC FUNCTIONS ========== */
function mint(
uint256 _collateral_amount,
uint256 _share_amount,
uint256 _dollar_out_min
) external {
}
function redeem(
uint256 _dollar_amount,
uint256 _share_out_min,
uint256 _collateral_out_min
) external {
}
function getNetDollarMinted() public view returns (uint256) {
}
function collectRedemption() external {
// make sure they wait x blocks
require(<FILL_ME>)
bool _send_share = false;
bool _send_collateral = false;
uint256 _share_amount;
uint256 _collateral_amount;
// Use Checks-Effects-Interactions pattern
if (redeem_share_balances[msg.sender] > 0) {
_share_amount = redeem_share_balances[msg.sender];
redeem_share_balances[msg.sender] = 0;
unclaimed_pool_share = unclaimed_pool_share - _share_amount;
_send_share = true;
}
if (redeem_collateral_balances[msg.sender] > 0) {
_collateral_amount = redeem_collateral_balances[msg.sender];
redeem_collateral_balances[msg.sender] = 0;
unclaimed_pool_collateral = unclaimed_pool_collateral - _collateral_amount;
_send_collateral = true;
}
if (_send_share) {
_requestTransferShare(msg.sender, _share_amount);
}
if (_send_collateral) {
_requestTransferCollateral(msg.sender, _collateral_amount);
}
}
function updatePeriod() internal {
}
/* ========== INTERNAL FUNCTIONS ========== */
function _transferCollateralToReserve(address _sender, uint256 _amount) internal {
}
function _mintShareToCollateralReserve(uint256 _amount) internal {
}
function _requestTransferCollateral(address _receiver, uint256 _amount) internal {
}
function _requestTransferShare(address _receiver, uint256 _amount) internal {
}
/* ========== RESTRICTED FUNCTIONS ========== */
function toggleMinting() external onlyOwner {
}
function toggleRedeeming() external onlyOwner {
}
function setOracle(address _oracle) external onlyOwner {
}
function setRedemptionDelay(uint256 _redemption_delay) external onlyOwner {
}
function setTreasury(address _treasury) external onlyOwner {
}
function setPeriod(uint256 _period) external onlyOwner {
}
function setMintLimit(uint256 _mintLimit) external onlyOwner {
}
function setRedeemLimit(uint256 _redeemLimit) external onlyOwner {
}
// EVENTS
event TreasuryChanged(address indexed newTreasury);
}
| (last_redeemed[msg.sender]+redemption_delay)<=block.number,"<redemption_delay" | 453,763 | (last_redeemed[msg.sender]+redemption_delay)<=block.number |
Subsets and Splits