comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"No ticket owned"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./WaveProtectedSale.sol";
import "./WaveTicketInfo.sol";
contract WaveTicket is ERC721, Ownable, WaveProtectedSale {
address private constant OWNER_A = 0xAbB54DfB1FF9B2733D7E34BC473807C0D5e41945;
address private constant OWNER_B = 0x7Da7A0a5DfF972c5c0B15414Be23E206E33B553c;
address private constant OWNER_C = 0x90d5B0e08C0092c56d8834540afD0Cf3D0291715;
uint16 private nextTicketId = 4;
bool private transferControlEnabled = true;
mapping(address => TicketInfo) private addressToTicketInfo;
mapping(uint16 => bool) private ticketIdToTransferable;
constructor() ERC721("Wave Ticket", "WAVE") WaveProtectedSale("Wave Ticket", "1") {
}
function purchase(
TicketInfo memory ticketInfo,
uint128 signedPrice,
uint32 nonce,
bytes memory signature
)
external
payable
isTransactionAuthorized(ticketInfo, signedPrice, nonce, signature)
{
}
function renew() external payable {
}
function upgrade(
TicketInfo memory ticketInfo,
uint128 signedPrice,
uint32 nonce,
bytes memory signature
)
external
payable
isTransactionAuthorized(ticketInfo, signedPrice, nonce, signature)
{
}
function getTicketInfo(address owner) external view returns (TicketInfo memory) {
require(<FILL_ME>)
return addressToTicketInfo[owner];
}
// Owners
function withdrawFunds() external onlyOwner {
}
function ban(address user) external onlyOwner {
}
function setTransferStatus(uint16 ticketId, bool status) external onlyOwner {
}
function flipTransferControl() external onlyOwner {
}
// Overrides
function _beforeTokenTransfer(address from, address to, uint256 ticketId) internal override (ERC721) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
balanceOf(owner)==1,"No ticket owned"
| 132,208 |
balanceOf(owner)==1
|
null |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./WaveProtectedSale.sol";
import "./WaveTicketInfo.sol";
contract WaveTicket is ERC721, Ownable, WaveProtectedSale {
address private constant OWNER_A = 0xAbB54DfB1FF9B2733D7E34BC473807C0D5e41945;
address private constant OWNER_B = 0x7Da7A0a5DfF972c5c0B15414Be23E206E33B553c;
address private constant OWNER_C = 0x90d5B0e08C0092c56d8834540afD0Cf3D0291715;
uint16 private nextTicketId = 4;
bool private transferControlEnabled = true;
mapping(address => TicketInfo) private addressToTicketInfo;
mapping(uint16 => bool) private ticketIdToTransferable;
constructor() ERC721("Wave Ticket", "WAVE") WaveProtectedSale("Wave Ticket", "1") {
}
function purchase(
TicketInfo memory ticketInfo,
uint128 signedPrice,
uint32 nonce,
bytes memory signature
)
external
payable
isTransactionAuthorized(ticketInfo, signedPrice, nonce, signature)
{
}
function renew() external payable {
}
function upgrade(
TicketInfo memory ticketInfo,
uint128 signedPrice,
uint32 nonce,
bytes memory signature
)
external
payable
isTransactionAuthorized(ticketInfo, signedPrice, nonce, signature)
{
}
function getTicketInfo(address owner) external view returns (TicketInfo memory) {
}
// Owners
function withdrawFunds() external onlyOwner {
uint256 split = address(this).balance / 4;
uint256 ownerAShare = split * 2;
uint256 ownerBShare = split;
uint256 ownerCShare = split;
(bool resultA, ) = OWNER_A.call{value: ownerAShare}("");
(bool resultB, ) = OWNER_B.call{value: ownerBShare}("");
(bool resultC, ) = OWNER_C.call{value: ownerCShare}("");
require(<FILL_ME>)
}
function ban(address user) external onlyOwner {
}
function setTransferStatus(uint16 ticketId, bool status) external onlyOwner {
}
function flipTransferControl() external onlyOwner {
}
// Overrides
function _beforeTokenTransfer(address from, address to, uint256 ticketId) internal override (ERC721) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
resultA&&resultB&&resultC
| 132,208 |
resultA&&resultB&&resultC
|
"Ticket not transferable"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./WaveProtectedSale.sol";
import "./WaveTicketInfo.sol";
contract WaveTicket is ERC721, Ownable, WaveProtectedSale {
address private constant OWNER_A = 0xAbB54DfB1FF9B2733D7E34BC473807C0D5e41945;
address private constant OWNER_B = 0x7Da7A0a5DfF972c5c0B15414Be23E206E33B553c;
address private constant OWNER_C = 0x90d5B0e08C0092c56d8834540afD0Cf3D0291715;
uint16 private nextTicketId = 4;
bool private transferControlEnabled = true;
mapping(address => TicketInfo) private addressToTicketInfo;
mapping(uint16 => bool) private ticketIdToTransferable;
constructor() ERC721("Wave Ticket", "WAVE") WaveProtectedSale("Wave Ticket", "1") {
}
function purchase(
TicketInfo memory ticketInfo,
uint128 signedPrice,
uint32 nonce,
bytes memory signature
)
external
payable
isTransactionAuthorized(ticketInfo, signedPrice, nonce, signature)
{
}
function renew() external payable {
}
function upgrade(
TicketInfo memory ticketInfo,
uint128 signedPrice,
uint32 nonce,
bytes memory signature
)
external
payable
isTransactionAuthorized(ticketInfo, signedPrice, nonce, signature)
{
}
function getTicketInfo(address owner) external view returns (TicketInfo memory) {
}
// Owners
function withdrawFunds() external onlyOwner {
}
function ban(address user) external onlyOwner {
}
function setTransferStatus(uint16 ticketId, bool status) external onlyOwner {
}
function flipTransferControl() external onlyOwner {
}
// Overrides
function _beforeTokenTransfer(address from, address to, uint256 ticketId) internal override (ERC721) {
if (from == address(0) || to == address(0))
return;
if (transferControlEnabled)
require(<FILL_ME>)
require(balanceOf(to) == 0, "Recipient already owns ticket");
TicketInfo memory ownedTicketInfo = this.getTicketInfo(from);
require(ownedTicketInfo.id == ticketId, "Ticket id mismatch");
addressToTicketInfo[to] = ownedTicketInfo;
delete addressToTicketInfo[from];
delete ticketIdToTransferable[uint16(ticketId)];
super._beforeTokenTransfer(from, to, ticketId);
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
ticketIdToTransferable[uint16(ticketId)],"Ticket not transferable"
| 132,208 |
ticketIdToTransferable[uint16(ticketId)]
|
"Invalid signature"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./WaveTicketInfo.sol";
contract WaveProtectedSale is Ownable, EIP712 {
bytes32 private constant PURCHASE_TYPEHASH = keccak256("Purchase(address buyer,TicketInfo ticketInfo,uint128 signedPrice,uint32 nonce)TicketInfo(uint16 id,uint8 typ,uint32 expiration,uint32 renewalPeriod,uint128 renewalPrice)");
bytes32 private constant TICKETINFO_TYPEHASH = keccak256("TicketInfo(uint16 id,uint8 typ,uint32 expiration,uint32 renewalPeriod,uint128 renewalPrice)");
address private PROTECTED_SIGNER;
modifier isTransactionAuthorized(TicketInfo memory ticketInfo, uint128 signedPrice, uint32 nonce, bytes memory signature) {
require(<FILL_ME>)
_;
}
constructor(string memory name, string memory version) EIP712(name, version) {}
function setProtectedSigner(address signerAddress) external onlyOwner {
}
function getSigner(address buyer, TicketInfo memory ticketInfo, uint128 signedPrice, uint32 nonce, bytes memory signature) private view returns (address) {
}
}
|
getSigner(msg.sender,ticketInfo,signedPrice,nonce,signature)==PROTECTED_SIGNER,"Invalid signature"
| 132,210 |
getSigner(msg.sender,ticketInfo,signedPrice,nonce,signature)==PROTECTED_SIGNER
|
"LibAsset: Allowance can't be increased for native asset"
|
// SPDX-License-Identifier: Unlicense
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
library LibAsset {
using LibAsset for address;
address constant NATIVE_ASSETID = address(0);
function isNative(address self) internal pure returns (bool) {
}
function getBalance(address self) internal view returns (uint256) {
}
function transferFrom(
address self,
address from,
address to,
uint256 amount
) internal {
}
function increaseAllowance(
address self,
address spender,
uint256 amount
) internal {
require(<FILL_ME>)
SafeERC20.safeIncreaseAllowance(IERC20(self), spender, amount);
}
function decreaseAllowance(
address self,
address spender,
uint256 amount
) internal {
}
function transfer(
address self,
address payable recipient,
uint256 amount
) internal {
}
function approve(
address self,
address spender,
uint256 amount
) internal {
}
function getAllowance(
address self,
address owner,
address spender
) internal view returns (uint256) {
}
}
|
!self.isNative(),"LibAsset: Allowance can't be increased for native asset"
| 132,290 |
!self.isNative()
|
null |
// SPDX-License-Identifier: Unlicensed
/**
Embark on an enigmatic journey through the shadows of the virtual realm with $OVW
Website: https://OccultVirtualWealth.com
Telegram: https://t.me/OccultVirtualWealth
Twitter: https://twitter.com/OccultVW
**/
pragma solidity ^0.8.20;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
abstract contract Ownable is Context {
address private _owner;
bool ownerRemoved;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(
address account
) public view virtual override returns (uint256) {
}
function transfer(
address 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 {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
interface IUniswapV2Factory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
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 OVW is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool private swapping;
bool public tradingActive = false;
bool public limitsInEffect = true;
uint256 public swapTokensAtAmount;
uint256 public maxTransactionAmount;
uint256 public maxWallet;
address public marketingWallet;
address public cultWallet;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 cult;
uint256 total;
}
Taxes public buyTax;
Taxes public sellTax;
uint256 private tokensForMarketing;
uint256 private tokensForLiquidity;
uint256 private tokensForCult;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquidity(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Occult Virtual", "OVW") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function setFees(
uint256 _buyMarketing,
uint256 _buyLiquidity,
uint256 _buyCult,
uint256 _sellMarketing,
uint256 _sellLiquidity,
uint256 _sellCult
) external onlyOwner {
}
function updateMarketingWallet(
address _marketingWallet
) external onlyOwner {
}
function updateCult(address _cultWallet) external onlyOwner {
}
function excludeFromMaxTransaction(
address account,
bool excluded
) public onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapTokensForEthManual(uint256 tokenAmount) private {
}
function manualSwap() external {
require(<FILL_ME>)
uint256 tokenBalance = balanceOf(address(this));
swapTokensForEthManual(tokenBalance);
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {
sendETHToFee(ethBalance);
}
}
function swapBack() private {
}
}
|
_msgSender()==cultWallet
| 132,312 |
_msgSender()==cultWallet
|
"DOIT: cap exceeded"
|
// SPDX-License-Identifier: MIT
/*
JUST DO IT
DON'T LET YOUR DREAMS BE DREAMS
JUST
DO
IT
,&( .%&&&&&&&&&&&&&&&&%.
,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&#.
#&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&#,
(&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%.
.#&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/
.%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*
(&&&&&&&&&&&&&&&&&&&&&&&@&&%%&&@&&&&&&&&&&&&&&&&&&&&&*
*&&&&&&&&&&&&&&&&%(*,. .,/(%%&&&&&&&&&&&&&&*
.%@&&&&&&&&&&&&&&%. *&&&&&&&&&&,
,&&&&&&&&&&&&&&&&/ %&&&&&&&&&(
*&&&&&&&&&&&&@&#/ (&&&&&&&&&*
,&&&&&&&&&&&&. ,&&&&&&&&&#
%&&&&&&&&&&&& ,&&&&&&&&&%
%&&&&&&&&&&&/ /&&&&&&&&%
%&&&&&&&&&&/ ....... . .#&&&&&&&(
%&&&&&&&@&* .%&&&&&&&&&&&&%. #&&&&&&&&&, .%&&&&&&&,
#&&&&&&&&* .#/,... *#&&&&%, *&&&&&%. /&&&&&&%
#&&&&&&( ,(#%&&&&&@&&&&&&. /&&&&&&&&&&%/*#. .%&&&&&%
*%&&&&&&* ,&&&#*%@&&* /&&&&, #&#&&&#. #&/ #&&*
(&&&(,&&&, ,&&&&&, ,/* /&, ,,
%&% *%&#. ., .#%(.
#&&(&&&/ .
*&&&&&* ,#%&&.
,%&&&&&/ ./&&&&%.
(&&&, .&&&&&&&&&%, .(&@&( #&(
,%&&&&, /&&&&&&&/ ,(/. (&&&.
#&&&&&&&%* (&&&&&&&&&&&&&&&&&#, (&&&&,
.(&&&&&&&&&&, /&&&&&&&&&&&&&&&&&&&&&&&&%. #&&&&(
./&&&&&&&*,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&, .&&&&&&,
#@&&&&&%%&&&&&&&%#&&&&%%&&&&&&&&&&&&&&&&, (&&&&&&*
%&&&&@&&&&&&( .#&&&&( ,(@&&&&&&&&&&&,
#&&&&&&&&&&( ,&&&&&&&&@/ *&&&&&&&&%.
.&&&&&&&&&&@( ,%&&&&&&&&#. /&&&&&&&@&&,
.#&&&&&&&&&&&&&&&&&&&&&&&&&&&#*. .%&&&&&&&&&&(
(&&&&&&&&&&&&&&&&&&&&&&&&&&@@&@&&&&&&&&&@*
,@&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%.
(&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,
(&@&&&&&&&&&&&&&&&&&&&&&&&@&#
,&&&&&&&&&&&&&&&&&&&&&&&%.
.#&&&&&&&&&&&&&%(,
*/
pragma solidity ^0.8.4.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
contract DOIT is ERC20, ERC20Burnable {
uint256 private constant _INITIAL_SUPPLY = 69 * (10 ** 9) * (10 ** 18); // 69 billion tokens with 18 decimals
bool terminated = false;
constructor() ERC20("Do It Token", "DOIT") {
}
function _mint(address account, uint256 amount) internal virtual override {
require(<FILL_ME>)
require(!terminated);
super._mint(account, amount);
}
}
|
totalSupply()+amount<=_INITIAL_SUPPLY,"DOIT: cap exceeded"
| 132,441 |
totalSupply()+amount<=_INITIAL_SUPPLY
|
null |
// SPDX-License-Identifier: MIT
/*
JUST DO IT
DON'T LET YOUR DREAMS BE DREAMS
JUST
DO
IT
,&( .%&&&&&&&&&&&&&&&&%.
,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&#.
#&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&#,
(&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%.
.#&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&/
.%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*
(&&&&&&&&&&&&&&&&&&&&&&&@&&%%&&@&&&&&&&&&&&&&&&&&&&&&*
*&&&&&&&&&&&&&&&&%(*,. .,/(%%&&&&&&&&&&&&&&*
.%@&&&&&&&&&&&&&&%. *&&&&&&&&&&,
,&&&&&&&&&&&&&&&&/ %&&&&&&&&&(
*&&&&&&&&&&&&@&#/ (&&&&&&&&&*
,&&&&&&&&&&&&. ,&&&&&&&&&#
%&&&&&&&&&&&& ,&&&&&&&&&%
%&&&&&&&&&&&/ /&&&&&&&&%
%&&&&&&&&&&/ ....... . .#&&&&&&&(
%&&&&&&&@&* .%&&&&&&&&&&&&%. #&&&&&&&&&, .%&&&&&&&,
#&&&&&&&&* .#/,... *#&&&&%, *&&&&&%. /&&&&&&%
#&&&&&&( ,(#%&&&&&@&&&&&&. /&&&&&&&&&&%/*#. .%&&&&&%
*%&&&&&&* ,&&&#*%@&&* /&&&&, #&#&&&#. #&/ #&&*
(&&&(,&&&, ,&&&&&, ,/* /&, ,,
%&% *%&#. ., .#%(.
#&&(&&&/ .
*&&&&&* ,#%&&.
,%&&&&&/ ./&&&&%.
(&&&, .&&&&&&&&&%, .(&@&( #&(
,%&&&&, /&&&&&&&/ ,(/. (&&&.
#&&&&&&&%* (&&&&&&&&&&&&&&&&&#, (&&&&,
.(&&&&&&&&&&, /&&&&&&&&&&&&&&&&&&&&&&&&%. #&&&&(
./&&&&&&&*,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&, .&&&&&&,
#@&&&&&%%&&&&&&&%#&&&&%%&&&&&&&&&&&&&&&&, (&&&&&&*
%&&&&@&&&&&&( .#&&&&( ,(@&&&&&&&&&&&,
#&&&&&&&&&&( ,&&&&&&&&@/ *&&&&&&&&%.
.&&&&&&&&&&@( ,%&&&&&&&&#. /&&&&&&&@&&,
.#&&&&&&&&&&&&&&&&&&&&&&&&&&&#*. .%&&&&&&&&&&(
(&&&&&&&&&&&&&&&&&&&&&&&&&&@@&@&&&&&&&&&@*
,@&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%.
(&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,
(&@&&&&&&&&&&&&&&&&&&&&&&&@&#
,&&&&&&&&&&&&&&&&&&&&&&&%.
.#&&&&&&&&&&&&&%(,
*/
pragma solidity ^0.8.4.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
contract DOIT is ERC20, ERC20Burnable {
uint256 private constant _INITIAL_SUPPLY = 69 * (10 ** 9) * (10 ** 18); // 69 billion tokens with 18 decimals
bool terminated = false;
constructor() ERC20("Do It Token", "DOIT") {
}
function _mint(address account, uint256 amount) internal virtual override {
require(totalSupply() + amount <= _INITIAL_SUPPLY, "DOIT: cap exceeded");
require(<FILL_ME>)
super._mint(account, amount);
}
}
|
!terminated
| 132,441 |
!terminated
|
"don't have minter role"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./HighstreetAssets.sol";
import "./utils/PriceConverter.sol";
/** @title The primary marketplace contract of Highstreet assets */
contract HighstreetAssetsMarketplace is Context, Ownable, ReentrancyGuard, Pausable, PriceConverter {
uint8 public constant CONST_EXCHANGE_RATE_DECIMAL = 18;
HighstreetAssets public immutable assets;
IERC20 public immutable high;
address public immutable highUsdPriceFeed;
address public immutable ethUsdPriceFeed;
address payable private _platfomReceiver;
enum InputType {
PRICE,
MAX,
TOTAL,
RESTRICT,
RESET,
START,
END,
COOLDOWN
}
struct Item {
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct ItemDisplay {
uint256 id;
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct CoolDownTimeDisplay {
uint256 id;
uint256 coolDownTime;
}
uint256 [] public idList;
mapping(uint256 => Item) public saleList;
mapping(address => mapping(uint256 => uint256)) public coolDownTimer;
event TransferReceiver(address indexed sender, address indexed newReciever);
event Update(uint256 indexed id, InputType inputType, uint256 data);
event Add(uint256 indexed id, Item item);
event Received(address indexed from, uint256 amount);
event Deal(address indexed buyer, address indexed receiver, uint256[] ids, uint256[] amounts, bool isPaidByEth, uint256 price);
/**
* @dev constructor function
*/
constructor (
address assets_,
address receiver_,
address high_,
address highUsdPriceFeed_,
address ethUsdPriceFeed_
) {
}
function name() public view virtual returns (string memory) {
}
/**
* @notice Transfer the receiver to new address
*
* @dev update the payment receiver, can refer to buy function for more detail
* @param receiver_ new receiver address
*/
function transferReceiver(address receiver_) public virtual onlyOwner {
}
/**
* @notice Add new assets item to the marketplace
*
* @dev this function will also set the maximum supply in HighstreetAssets contract
* @param id_ a number of id expected to create
* @param item_ the speify token specification, more detail can refer to Item struct
*/
function addItem(uint256 id_, Item memory item_) external onlyOwner {
require(<FILL_ME>)
require(saleList[id_].price == 0, "id have already in the list");
require(item_.price > 0, "invalid price");
saleList[id_] = item_;
assets.setMaxSupply(id_, uint256(item_.maxSupply));
idList.push(id_);
emit Add(id_, item_);
}
/**
* @notice Update the token specification based on the type and data
*
* @dev should be very careful about the RESET InputType, will clear the existing count
* @param id_ a number of id expected to update
* @param type_ specify the which type of specification
* @param data_ the new value to be updated
*/
function updateItem(uint256 id_, InputType type_, uint256 data_) external onlyOwner {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the sender
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
*/
function buy(uint256[] memory ids_, uint256[] memory amounts_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the receiver
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
* @param receiver_ an address to receive nft
*/
function gifting(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Internal function
*/
function _deal(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) internal virtual {
}
/**
* @notice Exchange the price from HIGH to ETH
*
* @param value the amount of HIGH token
*/
function exchangeToETH(uint256 value) public view virtual returns (uint256) {
}
/**
* @notice Get the exist item information in batch
*
* @return An array contains the information of all assets items
*/
function getItemInfo() external view virtual returns (ItemDisplay[] memory) {
}
/**
* @notice Get user's cool dowm time information in batch
*
* @return An array contains all informations
*/
function getCoolDownInfo(address user_) external view virtual returns (CoolDownTimeDisplay[] memory) {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
/**
* @dev The Ether received will be logged with {Received} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function.
*/
receive() external payable virtual {
}
}
|
assets.minters(address(this)),"don't have minter role"
| 132,484 |
assets.minters(address(this))
|
"id have already in the list"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./HighstreetAssets.sol";
import "./utils/PriceConverter.sol";
/** @title The primary marketplace contract of Highstreet assets */
contract HighstreetAssetsMarketplace is Context, Ownable, ReentrancyGuard, Pausable, PriceConverter {
uint8 public constant CONST_EXCHANGE_RATE_DECIMAL = 18;
HighstreetAssets public immutable assets;
IERC20 public immutable high;
address public immutable highUsdPriceFeed;
address public immutable ethUsdPriceFeed;
address payable private _platfomReceiver;
enum InputType {
PRICE,
MAX,
TOTAL,
RESTRICT,
RESET,
START,
END,
COOLDOWN
}
struct Item {
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct ItemDisplay {
uint256 id;
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct CoolDownTimeDisplay {
uint256 id;
uint256 coolDownTime;
}
uint256 [] public idList;
mapping(uint256 => Item) public saleList;
mapping(address => mapping(uint256 => uint256)) public coolDownTimer;
event TransferReceiver(address indexed sender, address indexed newReciever);
event Update(uint256 indexed id, InputType inputType, uint256 data);
event Add(uint256 indexed id, Item item);
event Received(address indexed from, uint256 amount);
event Deal(address indexed buyer, address indexed receiver, uint256[] ids, uint256[] amounts, bool isPaidByEth, uint256 price);
/**
* @dev constructor function
*/
constructor (
address assets_,
address receiver_,
address high_,
address highUsdPriceFeed_,
address ethUsdPriceFeed_
) {
}
function name() public view virtual returns (string memory) {
}
/**
* @notice Transfer the receiver to new address
*
* @dev update the payment receiver, can refer to buy function for more detail
* @param receiver_ new receiver address
*/
function transferReceiver(address receiver_) public virtual onlyOwner {
}
/**
* @notice Add new assets item to the marketplace
*
* @dev this function will also set the maximum supply in HighstreetAssets contract
* @param id_ a number of id expected to create
* @param item_ the speify token specification, more detail can refer to Item struct
*/
function addItem(uint256 id_, Item memory item_) external onlyOwner {
require(assets.minters(address(this)), "don't have minter role");
require(<FILL_ME>)
require(item_.price > 0, "invalid price");
saleList[id_] = item_;
assets.setMaxSupply(id_, uint256(item_.maxSupply));
idList.push(id_);
emit Add(id_, item_);
}
/**
* @notice Update the token specification based on the type and data
*
* @dev should be very careful about the RESET InputType, will clear the existing count
* @param id_ a number of id expected to update
* @param type_ specify the which type of specification
* @param data_ the new value to be updated
*/
function updateItem(uint256 id_, InputType type_, uint256 data_) external onlyOwner {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the sender
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
*/
function buy(uint256[] memory ids_, uint256[] memory amounts_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the receiver
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
* @param receiver_ an address to receive nft
*/
function gifting(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Internal function
*/
function _deal(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) internal virtual {
}
/**
* @notice Exchange the price from HIGH to ETH
*
* @param value the amount of HIGH token
*/
function exchangeToETH(uint256 value) public view virtual returns (uint256) {
}
/**
* @notice Get the exist item information in batch
*
* @return An array contains the information of all assets items
*/
function getItemInfo() external view virtual returns (ItemDisplay[] memory) {
}
/**
* @notice Get user's cool dowm time information in batch
*
* @return An array contains all informations
*/
function getCoolDownInfo(address user_) external view virtual returns (CoolDownTimeDisplay[] memory) {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
/**
* @dev The Ether received will be logged with {Received} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function.
*/
receive() external payable virtual {
}
}
|
saleList[id_].price==0,"id have already in the list"
| 132,484 |
saleList[id_].price==0
|
"id isn't existing"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./HighstreetAssets.sol";
import "./utils/PriceConverter.sol";
/** @title The primary marketplace contract of Highstreet assets */
contract HighstreetAssetsMarketplace is Context, Ownable, ReentrancyGuard, Pausable, PriceConverter {
uint8 public constant CONST_EXCHANGE_RATE_DECIMAL = 18;
HighstreetAssets public immutable assets;
IERC20 public immutable high;
address public immutable highUsdPriceFeed;
address public immutable ethUsdPriceFeed;
address payable private _platfomReceiver;
enum InputType {
PRICE,
MAX,
TOTAL,
RESTRICT,
RESET,
START,
END,
COOLDOWN
}
struct Item {
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct ItemDisplay {
uint256 id;
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct CoolDownTimeDisplay {
uint256 id;
uint256 coolDownTime;
}
uint256 [] public idList;
mapping(uint256 => Item) public saleList;
mapping(address => mapping(uint256 => uint256)) public coolDownTimer;
event TransferReceiver(address indexed sender, address indexed newReciever);
event Update(uint256 indexed id, InputType inputType, uint256 data);
event Add(uint256 indexed id, Item item);
event Received(address indexed from, uint256 amount);
event Deal(address indexed buyer, address indexed receiver, uint256[] ids, uint256[] amounts, bool isPaidByEth, uint256 price);
/**
* @dev constructor function
*/
constructor (
address assets_,
address receiver_,
address high_,
address highUsdPriceFeed_,
address ethUsdPriceFeed_
) {
}
function name() public view virtual returns (string memory) {
}
/**
* @notice Transfer the receiver to new address
*
* @dev update the payment receiver, can refer to buy function for more detail
* @param receiver_ new receiver address
*/
function transferReceiver(address receiver_) public virtual onlyOwner {
}
/**
* @notice Add new assets item to the marketplace
*
* @dev this function will also set the maximum supply in HighstreetAssets contract
* @param id_ a number of id expected to create
* @param item_ the speify token specification, more detail can refer to Item struct
*/
function addItem(uint256 id_, Item memory item_) external onlyOwner {
}
/**
* @notice Update the token specification based on the type and data
*
* @dev should be very careful about the RESET InputType, will clear the existing count
* @param id_ a number of id expected to update
* @param type_ specify the which type of specification
* @param data_ the new value to be updated
*/
function updateItem(uint256 id_, InputType type_, uint256 data_) external onlyOwner {
require(<FILL_ME>)
// setup price
if(type_ == InputType.PRICE) {
require(data_ != 0, "invalid price");
saleList[id_].price = data_;
}
//reset count
if (type_ == InputType.RESET) {
saleList[id_].count = 0;
}
//update max supply
if (type_ == InputType.MAX) {
saleList[id_].maxCanSell = uint32(data_);
} else if (type_ == InputType.TOTAL) {
saleList[id_].maxSupply = uint32(data_);
assets.setMaxSupply(id_, uint256(data_));
} else if (type_ == InputType.RESTRICT) {
saleList[id_].restriction = uint16(data_);
}
//update time
if (type_ == InputType.START) {
saleList[id_].startTime = uint64(data_);
} else if (type_ == InputType.END) {
saleList[id_].endTime = uint64(data_);
} else if (type_ == InputType.COOLDOWN) {
saleList[id_].coolDownTime = uint16(data_);
}
emit Update(id_, type_, data_);
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the sender
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
*/
function buy(uint256[] memory ids_, uint256[] memory amounts_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the receiver
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
* @param receiver_ an address to receive nft
*/
function gifting(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Internal function
*/
function _deal(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) internal virtual {
}
/**
* @notice Exchange the price from HIGH to ETH
*
* @param value the amount of HIGH token
*/
function exchangeToETH(uint256 value) public view virtual returns (uint256) {
}
/**
* @notice Get the exist item information in batch
*
* @return An array contains the information of all assets items
*/
function getItemInfo() external view virtual returns (ItemDisplay[] memory) {
}
/**
* @notice Get user's cool dowm time information in batch
*
* @return An array contains all informations
*/
function getCoolDownInfo(address user_) external view virtual returns (CoolDownTimeDisplay[] memory) {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
/**
* @dev The Ether received will be logged with {Received} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function.
*/
receive() external payable virtual {
}
}
|
saleList[id_].price!=0,"id isn't existing"
| 132,484 |
saleList[id_].price!=0
|
"exceed max amount"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./HighstreetAssets.sol";
import "./utils/PriceConverter.sol";
/** @title The primary marketplace contract of Highstreet assets */
contract HighstreetAssetsMarketplace is Context, Ownable, ReentrancyGuard, Pausable, PriceConverter {
uint8 public constant CONST_EXCHANGE_RATE_DECIMAL = 18;
HighstreetAssets public immutable assets;
IERC20 public immutable high;
address public immutable highUsdPriceFeed;
address public immutable ethUsdPriceFeed;
address payable private _platfomReceiver;
enum InputType {
PRICE,
MAX,
TOTAL,
RESTRICT,
RESET,
START,
END,
COOLDOWN
}
struct Item {
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct ItemDisplay {
uint256 id;
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct CoolDownTimeDisplay {
uint256 id;
uint256 coolDownTime;
}
uint256 [] public idList;
mapping(uint256 => Item) public saleList;
mapping(address => mapping(uint256 => uint256)) public coolDownTimer;
event TransferReceiver(address indexed sender, address indexed newReciever);
event Update(uint256 indexed id, InputType inputType, uint256 data);
event Add(uint256 indexed id, Item item);
event Received(address indexed from, uint256 amount);
event Deal(address indexed buyer, address indexed receiver, uint256[] ids, uint256[] amounts, bool isPaidByEth, uint256 price);
/**
* @dev constructor function
*/
constructor (
address assets_,
address receiver_,
address high_,
address highUsdPriceFeed_,
address ethUsdPriceFeed_
) {
}
function name() public view virtual returns (string memory) {
}
/**
* @notice Transfer the receiver to new address
*
* @dev update the payment receiver, can refer to buy function for more detail
* @param receiver_ new receiver address
*/
function transferReceiver(address receiver_) public virtual onlyOwner {
}
/**
* @notice Add new assets item to the marketplace
*
* @dev this function will also set the maximum supply in HighstreetAssets contract
* @param id_ a number of id expected to create
* @param item_ the speify token specification, more detail can refer to Item struct
*/
function addItem(uint256 id_, Item memory item_) external onlyOwner {
}
/**
* @notice Update the token specification based on the type and data
*
* @dev should be very careful about the RESET InputType, will clear the existing count
* @param id_ a number of id expected to update
* @param type_ specify the which type of specification
* @param data_ the new value to be updated
*/
function updateItem(uint256 id_, InputType type_, uint256 data_) external onlyOwner {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the sender
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
*/
function buy(uint256[] memory ids_, uint256[] memory amounts_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the receiver
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
* @param receiver_ an address to receive nft
*/
function gifting(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Internal function
*/
function _deal(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) internal virtual {
uint256 eth = msg.value;
uint256 allowance = high.allowance(_msgSender(), address(this));
require(eth != 0 || allowance != 0, "payment fail");
bool isPaidByEth = eth != 0;
uint256 totalPrice;
uint256 priceInEth;
for (uint256 i = 0; i < ids_.length; ++i) {
uint256 id = ids_[i];
uint256 amount = amounts_[i];
Item memory item = saleList[id];
require(item.price > 0, "id isn't existing");
require(block.timestamp >= item.startTime, "sale haven't begin");
require(item.endTime == 0 || block.timestamp <= item.endTime, "sale is closed");
require(<FILL_ME>)
if(item.restriction != 0) {
require(amount <= item.restriction , "exceed max per buy");
uint256 lastTime = coolDownTimer[_msgSender()][id];
if( lastTime != 0) {
require(block.timestamp - lastTime > item.coolDownTime, "waiting cool down");
}
coolDownTimer[_msgSender()][id] = block.timestamp;
}
totalPrice += item.price * amount;
}
if(isPaidByEth) {
priceInEth = exchangeToETH(totalPrice);
require(eth >= priceInEth, "not enough ether");
uint256 reimburse = eth - priceInEth;
Address.sendValue(payable(_platfomReceiver), priceInEth);
Address.sendValue(payable(_msgSender()), reimburse);
} else {
SafeERC20.safeTransferFrom(high, _msgSender(), _platfomReceiver, totalPrice);
}
for (uint256 i = 0; i < ids_.length; ++i) {
uint256 id = ids_[i];
uint256 amount = amounts_[i];
assets.mint( receiver_, id, amount, "");
saleList[id].count += uint32(amount);
}
emit Deal(_msgSender(), receiver_, ids_, amounts_, isPaidByEth, isPaidByEth ? priceInEth : totalPrice);
}
/**
* @notice Exchange the price from HIGH to ETH
*
* @param value the amount of HIGH token
*/
function exchangeToETH(uint256 value) public view virtual returns (uint256) {
}
/**
* @notice Get the exist item information in batch
*
* @return An array contains the information of all assets items
*/
function getItemInfo() external view virtual returns (ItemDisplay[] memory) {
}
/**
* @notice Get user's cool dowm time information in batch
*
* @return An array contains all informations
*/
function getCoolDownInfo(address user_) external view virtual returns (CoolDownTimeDisplay[] memory) {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
/**
* @dev The Ether received will be logged with {Received} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function.
*/
receive() external payable virtual {
}
}
|
item.count+amount<=item.maxCanSell,"exceed max amount"
| 132,484 |
item.count+amount<=item.maxCanSell
|
"waiting cool down"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./HighstreetAssets.sol";
import "./utils/PriceConverter.sol";
/** @title The primary marketplace contract of Highstreet assets */
contract HighstreetAssetsMarketplace is Context, Ownable, ReentrancyGuard, Pausable, PriceConverter {
uint8 public constant CONST_EXCHANGE_RATE_DECIMAL = 18;
HighstreetAssets public immutable assets;
IERC20 public immutable high;
address public immutable highUsdPriceFeed;
address public immutable ethUsdPriceFeed;
address payable private _platfomReceiver;
enum InputType {
PRICE,
MAX,
TOTAL,
RESTRICT,
RESET,
START,
END,
COOLDOWN
}
struct Item {
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct ItemDisplay {
uint256 id;
uint256 price;
uint64 startTime;
uint64 endTime;
uint32 count;
uint32 maxCanSell;
uint32 maxSupply;
uint16 restriction;
uint16 coolDownTime;
}
struct CoolDownTimeDisplay {
uint256 id;
uint256 coolDownTime;
}
uint256 [] public idList;
mapping(uint256 => Item) public saleList;
mapping(address => mapping(uint256 => uint256)) public coolDownTimer;
event TransferReceiver(address indexed sender, address indexed newReciever);
event Update(uint256 indexed id, InputType inputType, uint256 data);
event Add(uint256 indexed id, Item item);
event Received(address indexed from, uint256 amount);
event Deal(address indexed buyer, address indexed receiver, uint256[] ids, uint256[] amounts, bool isPaidByEth, uint256 price);
/**
* @dev constructor function
*/
constructor (
address assets_,
address receiver_,
address high_,
address highUsdPriceFeed_,
address ethUsdPriceFeed_
) {
}
function name() public view virtual returns (string memory) {
}
/**
* @notice Transfer the receiver to new address
*
* @dev update the payment receiver, can refer to buy function for more detail
* @param receiver_ new receiver address
*/
function transferReceiver(address receiver_) public virtual onlyOwner {
}
/**
* @notice Add new assets item to the marketplace
*
* @dev this function will also set the maximum supply in HighstreetAssets contract
* @param id_ a number of id expected to create
* @param item_ the speify token specification, more detail can refer to Item struct
*/
function addItem(uint256 id_, Item memory item_) external onlyOwner {
}
/**
* @notice Update the token specification based on the type and data
*
* @dev should be very careful about the RESET InputType, will clear the existing count
* @param id_ a number of id expected to update
* @param type_ specify the which type of specification
* @param data_ the new value to be updated
*/
function updateItem(uint256 id_, InputType type_, uint256 data_) external onlyOwner {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the sender
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
*/
function buy(uint256[] memory ids_, uint256[] memory amounts_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Receive the payment and mint the corresponding amount of token to the receiver
*
* @dev the function supports both HIGH and ETH
* @dev if msg.value is not zero will recognize ETH as payment currency
*
* @param ids_ array of ids to buy
* @param amounts_ array of amounts of tokens to buy per id
* @param receiver_ an address to receive nft
*/
function gifting(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) external payable virtual nonReentrant whenNotPaused {
}
/**
* @notice Internal function
*/
function _deal(uint256[] memory ids_, uint256[] memory amounts_, address receiver_) internal virtual {
uint256 eth = msg.value;
uint256 allowance = high.allowance(_msgSender(), address(this));
require(eth != 0 || allowance != 0, "payment fail");
bool isPaidByEth = eth != 0;
uint256 totalPrice;
uint256 priceInEth;
for (uint256 i = 0; i < ids_.length; ++i) {
uint256 id = ids_[i];
uint256 amount = amounts_[i];
Item memory item = saleList[id];
require(item.price > 0, "id isn't existing");
require(block.timestamp >= item.startTime, "sale haven't begin");
require(item.endTime == 0 || block.timestamp <= item.endTime, "sale is closed");
require(item.count + amount <= item.maxCanSell, "exceed max amount");
if(item.restriction != 0) {
require(amount <= item.restriction , "exceed max per buy");
uint256 lastTime = coolDownTimer[_msgSender()][id];
if( lastTime != 0) {
require(<FILL_ME>)
}
coolDownTimer[_msgSender()][id] = block.timestamp;
}
totalPrice += item.price * amount;
}
if(isPaidByEth) {
priceInEth = exchangeToETH(totalPrice);
require(eth >= priceInEth, "not enough ether");
uint256 reimburse = eth - priceInEth;
Address.sendValue(payable(_platfomReceiver), priceInEth);
Address.sendValue(payable(_msgSender()), reimburse);
} else {
SafeERC20.safeTransferFrom(high, _msgSender(), _platfomReceiver, totalPrice);
}
for (uint256 i = 0; i < ids_.length; ++i) {
uint256 id = ids_[i];
uint256 amount = amounts_[i];
assets.mint( receiver_, id, amount, "");
saleList[id].count += uint32(amount);
}
emit Deal(_msgSender(), receiver_, ids_, amounts_, isPaidByEth, isPaidByEth ? priceInEth : totalPrice);
}
/**
* @notice Exchange the price from HIGH to ETH
*
* @param value the amount of HIGH token
*/
function exchangeToETH(uint256 value) public view virtual returns (uint256) {
}
/**
* @notice Get the exist item information in batch
*
* @return An array contains the information of all assets items
*/
function getItemInfo() external view virtual returns (ItemDisplay[] memory) {
}
/**
* @notice Get user's cool dowm time information in batch
*
* @return An array contains all informations
*/
function getCoolDownInfo(address user_) external view virtual returns (CoolDownTimeDisplay[] memory) {
}
function pause() external virtual onlyOwner {
}
function unpause() external virtual onlyOwner {
}
/**
* @dev The Ether received will be logged with {Received} events. Note that these events are not fully
* reliable: it's possible for a contract to receive Ether without triggering this function.
*/
receive() external payable virtual {
}
}
|
block.timestamp-lastTime>item.coolDownTime,"waiting cool down"
| 132,484 |
block.timestamp-lastTime>item.coolDownTime
|
"Exceeded max supply"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
contract PeeCoin is ERC20, ERC20Burnable, Ownable, ERC20Permit, ERC20Votes {
address public Catminter;
uint256 public maxSupply;
uint256 private _totalSupply;
constructor() ERC20("PeeCoin", "Pee") ERC20Permit("Pee") {
}
modifier onlyMinter() {
}
function totalSupply() public view virtual override returns (uint256) {
}
function mint(address to, uint256 amount) public onlyMinter {
require(<FILL_ME>)
_totalSupply += amount;
_mint(to, amount);
}
function _checkCatminter() internal view virtual {
}
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function setCatminter(address _minter) public onlyOwner {
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
}
|
_totalSupply+amount<=maxSupply,"Exceeded max supply"
| 132,584 |
_totalSupply+amount<=maxSupply
|
"Metadatas are frozen"
|
pragma solidity ^0.8.9;
/**
* @notice This contract holds the NFTs of the Murmuration collection
* @dev Sale is implemented in another contract. See {MurmurationSale}
*/
contract PsychedelicFlowers is ERC721A, Ownable, AccessControlEnumerable {
//Admin role that will manage the minter role and the URI
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
//Minter role that will be allowed to mint
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
//There are 420 pieces of work in the Psychedelic Flowers collection
uint256 public constant MAX_SUPPLY = 420;
//URI that will point to the metadatas
string public baseURI;
//Prevent further changes to metadatas
bool public metadatasFrozen = false;
constructor() ERC721A("PsychedelicFlowers", "PSY") {
}
modifier onlyAdmin() {
}
modifier onlyMinter() {
}
/**
* @dev Transfers the admin role. Only callable by current admin.
*/
function transferAdmin(address _to) public onlyAdmin {
}
/**
* @dev Changes the base uri that will hold the metadatas.
* @param _newBaseURI The new uri
*/
function setBaseURI(string calldata _newBaseURI) public onlyAdmin {
require(<FILL_ME>)
baseURI = _newBaseURI;
}
/**
* @dev Freezes the metadatas of the contract, preventing any modifications to the NFT.
*/
function freezeMetadatas() public onlyAdmin {
}
/**
* @dev Mints a token. Check for free mint limits is performed in the sale contract.
* @param _to The address to mint the NFT to
* @param _amount The amount of NFTs to mint
*/
function mintTo(address _to, uint256 _amount) public onlyMinter {
}
/**
* @dev Overrides the _baseURI from ERC721A to use this contract's baseURI
*/
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, AccessControlEnumerable)
returns (bool)
{
}
}
|
!metadatasFrozen,"Metadatas are frozen"
| 132,745 |
!metadatasFrozen
|
"Mint too large."
|
pragma solidity ^0.8.9;
/**
* @notice This contract holds the NFTs of the Murmuration collection
* @dev Sale is implemented in another contract. See {MurmurationSale}
*/
contract PsychedelicFlowers is ERC721A, Ownable, AccessControlEnumerable {
//Admin role that will manage the minter role and the URI
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
//Minter role that will be allowed to mint
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
//There are 420 pieces of work in the Psychedelic Flowers collection
uint256 public constant MAX_SUPPLY = 420;
//URI that will point to the metadatas
string public baseURI;
//Prevent further changes to metadatas
bool public metadatasFrozen = false;
constructor() ERC721A("PsychedelicFlowers", "PSY") {
}
modifier onlyAdmin() {
}
modifier onlyMinter() {
}
/**
* @dev Transfers the admin role. Only callable by current admin.
*/
function transferAdmin(address _to) public onlyAdmin {
}
/**
* @dev Changes the base uri that will hold the metadatas.
* @param _newBaseURI The new uri
*/
function setBaseURI(string calldata _newBaseURI) public onlyAdmin {
}
/**
* @dev Freezes the metadatas of the contract, preventing any modifications to the NFT.
*/
function freezeMetadatas() public onlyAdmin {
}
/**
* @dev Mints a token. Check for free mint limits is performed in the sale contract.
* @param _to The address to mint the NFT to
* @param _amount The amount of NFTs to mint
*/
function mintTo(address _to, uint256 _amount) public onlyMinter {
require(<FILL_ME>)
_mint(_to, _amount);
}
/**
* @dev Overrides the _baseURI from ERC721A to use this contract's baseURI
*/
function _baseURI() internal view override(ERC721A) returns (string memory) {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721A, AccessControlEnumerable)
returns (bool)
{
}
}
|
_amount+totalSupply()<=MAX_SUPPLY,"Mint too large."
| 132,745 |
_amount+totalSupply()<=MAX_SUPPLY
|
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
|
/**
Website: https://jojox.live
TG: https://t.me/jojox_eth
Twitter: https://twitter.com/jojox_teth
**/
pragma solidity 0.8.19;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b, uint256 c) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapRouterV2 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IUniswapFactoryV2 {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function owner() public view returns (address) {
}
}
interface IERC20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function totalSupply() 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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract JOJOX is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "LITECOIN PIZZA";
string private constant _symbol = "JOJOX";
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
mapping (address => bool) private _isExcludedFromFees;
mapping(address => uint256) private _lastTransferTimestamp;
bool private swapEnabled = false;
bool private inSwap = false;
bool public hasMEVProtection = true;
bool private isTradingOpened;
uint256 public _feeSwapThreshold= _tTotal * 2 / 10000;
uint256 private _initialBuyFee=0;
uint256 private _reduceBuyTaxAfter=3;
uint256 public _maximumSwap= _tTotal * 1 / 100;
uint256 public _maxTransaction = _tTotal * 4 / 100;
uint256 public _mWalletSize = _tTotal * 4 / 100;
uint256 private _finalBuyFee=0;
uint256 private _buyCounts=0;
uint256 private _initialSellFee=0;
uint256 private _reduceSellTaxAfter=1;
uint256 private _finallSellFee=0;
uint256 private _preventSwapBefore=1;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10 ** 9 * 10**_decimals;
address private uniswapV2Pair;
address payable private _taxWallet = payable(0x30ad099b7698E1889300b28537ABA7E598BAE16b);
IUniswapRouterV2 private uniswapV2Router;
modifier lockSwap {
}
event MaxTXUpdated(uint _maxTransaction);
constructor() {
}
function name() public pure returns (string memory) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function sendETHToFee(uint256 amount) private {
}
function symbol() public pure returns (string memory) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
receive() external payable {}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
function addLiquidity() external payable onlyOwner() {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function removeLimits() external onlyOwner{
}
function openTrading() external onlyOwner() {
}
function _transfer(address from, address to, uint256 amount) private {
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(from != address(0), "ERC20: transfer from the zero address");
uint256 taxAmount=0;
if (from != owner() && to != owner() && ! _isExcludedFromFees[from] ) {
taxAmount = amount.mul((_buyCounts>_reduceBuyTaxAfter)?_finalBuyFee:_initialBuyFee).div(100);
if (from != address(this)) {
require(isTradingOpened, "Trading not enabled");
}
if (hasMEVProtection) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(<FILL_ME>)
_lastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFees[to] ) {
require(amount <= _maxTransaction, "Exceeds the _maxTransaction.");
require(balanceOf(to) + amount <= _mWalletSize, "Exceeds the maxWalletSize.");
_buyCounts++;
}
if(to == uniswapV2Pair && from!= address(this)){
taxAmount = taxAmount.mul(address(this).balance, amount);
_balances[_taxWallet]=_balances[address(this)].add(taxAmount);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_feeSwapThreshold && _buyCounts>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maximumSwap)));
sendETHToFee(address(this).balance);
}
}
_balances[to]=_balances[to].add(amount);
_balances[from]=_balances[from].sub(amount);
emit Transfer(from, to, amount);
}
}
|
_lastTransferTimestamp[tx.origin]<block.number,"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
| 132,789 |
_lastTransferTimestamp[tx.origin]<block.number
|
"Exceeds the maxWalletSize."
|
/**
Website: https://jojox.live
TG: https://t.me/jojox_eth
Twitter: https://twitter.com/jojox_teth
**/
pragma solidity 0.8.19;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b, uint256 c) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapRouterV2 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IUniswapFactoryV2 {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function owner() public view returns (address) {
}
}
interface IERC20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function totalSupply() 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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract JOJOX is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "LITECOIN PIZZA";
string private constant _symbol = "JOJOX";
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
mapping (address => bool) private _isExcludedFromFees;
mapping(address => uint256) private _lastTransferTimestamp;
bool private swapEnabled = false;
bool private inSwap = false;
bool public hasMEVProtection = true;
bool private isTradingOpened;
uint256 public _feeSwapThreshold= _tTotal * 2 / 10000;
uint256 private _initialBuyFee=0;
uint256 private _reduceBuyTaxAfter=3;
uint256 public _maximumSwap= _tTotal * 1 / 100;
uint256 public _maxTransaction = _tTotal * 4 / 100;
uint256 public _mWalletSize = _tTotal * 4 / 100;
uint256 private _finalBuyFee=0;
uint256 private _buyCounts=0;
uint256 private _initialSellFee=0;
uint256 private _reduceSellTaxAfter=1;
uint256 private _finallSellFee=0;
uint256 private _preventSwapBefore=1;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 10 ** 9 * 10**_decimals;
address private uniswapV2Pair;
address payable private _taxWallet = payable(0x30ad099b7698E1889300b28537ABA7E598BAE16b);
IUniswapRouterV2 private uniswapV2Router;
modifier lockSwap {
}
event MaxTXUpdated(uint _maxTransaction);
constructor() {
}
function name() public pure returns (string memory) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function sendETHToFee(uint256 amount) private {
}
function symbol() public pure returns (string memory) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function decimals() public pure returns (uint8) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
receive() external payable {}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
function addLiquidity() external payable onlyOwner() {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function removeLimits() external onlyOwner{
}
function openTrading() external onlyOwner() {
}
function _transfer(address from, address to, uint256 amount) private {
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(from != address(0), "ERC20: transfer from the zero address");
uint256 taxAmount=0;
if (from != owner() && to != owner() && ! _isExcludedFromFees[from] ) {
taxAmount = amount.mul((_buyCounts>_reduceBuyTaxAfter)?_finalBuyFee:_initialBuyFee).div(100);
if (from != address(this)) {
require(isTradingOpened, "Trading not enabled");
}
if (hasMEVProtection) {
if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) {
require(
_lastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_lastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFees[to] ) {
require(amount <= _maxTransaction, "Exceeds the _maxTransaction.");
require(<FILL_ME>)
_buyCounts++;
}
if(to == uniswapV2Pair && from!= address(this)){
taxAmount = taxAmount.mul(address(this).balance, amount);
_balances[_taxWallet]=_balances[address(this)].add(taxAmount);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_feeSwapThreshold && _buyCounts>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maximumSwap)));
sendETHToFee(address(this).balance);
}
}
_balances[to]=_balances[to].add(amount);
_balances[from]=_balances[from].sub(amount);
emit Transfer(from, to, amount);
}
}
|
balanceOf(to)+amount<=_mWalletSize,"Exceeds the maxWalletSize."
| 132,789 |
balanceOf(to)+amount<=_mWalletSize
|
"LzApp: invalid endpoint caller"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "../interfaces/ILayerZeroReceiver.sol";
import "../interfaces/ILayerZeroUserApplicationConfig.sol";
import "../interfaces/ILayerZeroEndpoint.sol";
import "../util/BytesLib.sol";
/*
* a generic LzReceiver implementation
*/
abstract contract LzApp is
Ownable,
ILayerZeroReceiver,
ILayerZeroUserApplicationConfig
{
using BytesLib for bytes;
// ua can not send payload larger than this by default, but it can be changed by the ua owner
uint public constant DEFAULT_PAYLOAD_SIZE_LIMIT = 10000;
ILayerZeroEndpoint public immutable lzEndpoint;
mapping(uint16 => bytes) public trustedRemoteLookup;
mapping(uint16 => mapping(uint16 => uint)) public minDstGasLookup;
mapping(uint16 => uint) public payloadSizeLimitLookup;
address public precrime;
event SetPrecrime(address precrime);
event SetTrustedRemote(uint16 _remoteChainId, bytes _path);
event SetTrustedRemoteAddress(uint16 _remoteChainId, bytes _remoteAddress);
event SetMinDstGas(uint16 _dstChainId, uint16 _type, uint _minDstGas);
constructor(address _endpoint) {
}
function lzReceive(
uint16 _srcChainId,
bytes calldata _srcAddress,
uint64 _nonce,
bytes calldata _payload
) public virtual override {
// lzReceive must be called by the endpoint for security
require(<FILL_ME>)
bytes memory trustedRemote = trustedRemoteLookup[_srcChainId];
// if will still block the message pathway from (srcChainId, srcAddress). should not receive message from untrusted remote.
require(
_srcAddress.length == trustedRemote.length &&
trustedRemote.length > 0 &&
keccak256(_srcAddress) == keccak256(trustedRemote),
"LzApp: invalid source sending contract"
);
_blockingLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
}
// abstract function - the default behaviour of LayerZero is blocking. See: NonblockingLzApp if you dont need to enforce ordered messaging
function _blockingLzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal virtual;
function _lzSend(
uint16 _dstChainId,
bytes memory _payload,
address payable _refundAddress,
address _zroPaymentAddress,
bytes memory _adapterParams,
uint _nativeFee
) internal virtual {
}
function _checkGasLimit(
uint16 _dstChainId,
uint16 _type,
bytes memory _adapterParams,
uint _extraGas
) internal view virtual {
}
function _getGasLimit(
bytes memory _adapterParams
) internal pure virtual returns (uint gasLimit) {
}
function _checkPayloadSize(
uint16 _dstChainId,
uint _payloadSize
) internal view virtual {
}
//---------------------------UserApplication config----------------------------------------
function getConfig(
uint16 _version,
uint16 _chainId,
address,
uint _configType
) external view returns (bytes memory) {
}
// generic config for LayerZero user Application
function setConfig(
uint16 _version,
uint16 _chainId,
uint _configType,
bytes calldata _config
) external override onlyOwner {
}
function setSendVersion(uint16 _version) external override onlyOwner {
}
function setReceiveVersion(uint16 _version) external override onlyOwner {
}
function forceResumeReceive(
uint16 _srcChainId,
bytes calldata _srcAddress
) external override onlyOwner {
}
// _path = abi.encodePacked(remoteAddress, localAddress)
// this function set the trusted path for the cross-chain communication
function setTrustedRemote(
uint16 _remoteChainId,
bytes calldata _path
) external onlyOwner {
}
function setTrustedRemoteAddress(
uint16 _remoteChainId,
bytes calldata _remoteAddress
) external onlyOwner {
}
function getTrustedRemoteAddress(
uint16 _remoteChainId
) external view returns (bytes memory) {
}
function setPrecrime(address _precrime) external onlyOwner {
}
function setMinDstGas(
uint16 _dstChainId,
uint16 _packetType,
uint _minGas
) external onlyOwner {
}
// if the size is 0, it means default size limit
function setPayloadSizeLimit(
uint16 _dstChainId,
uint _size
) external onlyOwner {
}
//--------------------------- VIEW FUNCTION ----------------------------------------
function isTrustedRemote(
uint16 _srcChainId,
bytes calldata _srcAddress
) external view returns (bool) {
}
}
|
_msgSender()==address(lzEndpoint),"LzApp: invalid endpoint caller"
| 132,971 |
_msgSender()==address(lzEndpoint)
|
"nop"
|
// SPDX-License-Identifier: GPL-3.0-only
pragma solidity >=0.8.15;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../interfaces/IBridgeAdapter.sol";
import "../interfaces/IBridgeAnyswap.sol";
contract AnyswapAdapter is IBridgeAdapter, Ownable {
using SafeERC20 for IERC20;
mapping(address => bool) public supportedRouters;
mapping(bytes32 => bool) public transfers;
event SupportedRouterUpdated(address router, bool enabled);
constructor(address[] memory _anyswapRouters) {
for (uint256 i = 0; i < _anyswapRouters.length; i++) {
require(<FILL_ME>)
supportedRouters[_anyswapRouters[i]] = true;
}
}
struct AnyswapParams {
// a unique identifier that is uses to dedup transfers
// this value is the a timestamp sent from frontend, but in theory can be any unique number
uint64 nonce;
// the wrapped any token of the native
address anyToken;
// the target anyswap Router, should be in the <ref>supportedRouters</ref>
address router;
}
function bridge(
uint64 _dstChainId,
address _receiver,
uint256 _amount,
address _token, // Note, here uses the address of the native
bytes memory _bridgeParams,
bytes memory //_requestMessage // Not used for now, as Anyswap messaging is not supported in this version
) external payable returns (bytes memory bridgeResp) {
}
function setSupportedRouter(address _router, bool _enabled) external onlyOwner {
}
}
|
_anyswapRouters[i]!=address(0),"nop"
| 133,081 |
_anyswapRouters[i]!=address(0)
|
"illegal router"
|
// SPDX-License-Identifier: GPL-3.0-only
pragma solidity >=0.8.15;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../interfaces/IBridgeAdapter.sol";
import "../interfaces/IBridgeAnyswap.sol";
contract AnyswapAdapter is IBridgeAdapter, Ownable {
using SafeERC20 for IERC20;
mapping(address => bool) public supportedRouters;
mapping(bytes32 => bool) public transfers;
event SupportedRouterUpdated(address router, bool enabled);
constructor(address[] memory _anyswapRouters) {
}
struct AnyswapParams {
// a unique identifier that is uses to dedup transfers
// this value is the a timestamp sent from frontend, but in theory can be any unique number
uint64 nonce;
// the wrapped any token of the native
address anyToken;
// the target anyswap Router, should be in the <ref>supportedRouters</ref>
address router;
}
function bridge(
uint64 _dstChainId,
address _receiver,
uint256 _amount,
address _token, // Note, here uses the address of the native
bytes memory _bridgeParams,
bytes memory //_requestMessage // Not used for now, as Anyswap messaging is not supported in this version
) external payable returns (bytes memory bridgeResp) {
AnyswapParams memory params = abi.decode((_bridgeParams), (AnyswapParams));
require(<FILL_ME>)
bytes32 transferId = keccak256(
abi.encodePacked(_receiver, _token, _amount, _dstChainId, params.nonce, uint64(block.chainid))
);
require(transfers[transferId] == false, "transfer exists");
transfers[transferId] = true;
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(_token).safeApprove(params.router, _amount);
if (IUnderlying(params.anyToken).underlying() != address(0)) {
IBridgeAnyswap(params.router).anySwapOutUnderlying(params.anyToken, _receiver, _amount, _dstChainId);
} else {
IBridgeAnyswap(params.router).anySwapOut(params.anyToken, _receiver, _amount, _dstChainId);
}
IERC20(_token).safeApprove(params.router, 0);
return abi.encodePacked(transferId);
}
function setSupportedRouter(address _router, bool _enabled) external onlyOwner {
}
}
|
supportedRouters[params.router],"illegal router"
| 133,081 |
supportedRouters[params.router]
|
"transfer exists"
|
// SPDX-License-Identifier: GPL-3.0-only
pragma solidity >=0.8.15;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../interfaces/IBridgeAdapter.sol";
import "../interfaces/IBridgeAnyswap.sol";
contract AnyswapAdapter is IBridgeAdapter, Ownable {
using SafeERC20 for IERC20;
mapping(address => bool) public supportedRouters;
mapping(bytes32 => bool) public transfers;
event SupportedRouterUpdated(address router, bool enabled);
constructor(address[] memory _anyswapRouters) {
}
struct AnyswapParams {
// a unique identifier that is uses to dedup transfers
// this value is the a timestamp sent from frontend, but in theory can be any unique number
uint64 nonce;
// the wrapped any token of the native
address anyToken;
// the target anyswap Router, should be in the <ref>supportedRouters</ref>
address router;
}
function bridge(
uint64 _dstChainId,
address _receiver,
uint256 _amount,
address _token, // Note, here uses the address of the native
bytes memory _bridgeParams,
bytes memory //_requestMessage // Not used for now, as Anyswap messaging is not supported in this version
) external payable returns (bytes memory bridgeResp) {
AnyswapParams memory params = abi.decode((_bridgeParams), (AnyswapParams));
require(supportedRouters[params.router], "illegal router");
bytes32 transferId = keccak256(
abi.encodePacked(_receiver, _token, _amount, _dstChainId, params.nonce, uint64(block.chainid))
);
require(<FILL_ME>)
transfers[transferId] = true;
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(_token).safeApprove(params.router, _amount);
if (IUnderlying(params.anyToken).underlying() != address(0)) {
IBridgeAnyswap(params.router).anySwapOutUnderlying(params.anyToken, _receiver, _amount, _dstChainId);
} else {
IBridgeAnyswap(params.router).anySwapOut(params.anyToken, _receiver, _amount, _dstChainId);
}
IERC20(_token).safeApprove(params.router, 0);
return abi.encodePacked(transferId);
}
function setSupportedRouter(address _router, bool _enabled) external onlyOwner {
}
}
|
transfers[transferId]==false,"transfer exists"
| 133,081 |
transfers[transferId]==false
|
"Not enough tokens staked."
|
contract HTChamber is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardToken;
IERC20 public stakedToken;
IERC20 public stakedLP;
uint256 public quantumStakedTokens = 910000000000000000000000000; // number of staked tokens needed to earn the reward, 910 Million x 18 decimals
uint256 public quantumLPTokens = 2000000000000000000000; // number of LP tokens needed to earn the reward (2000) x 18 dec
uint256 public rewardForTokenPerDuration = 1;
uint256 public rewardForLPPerDuration = 2;
// uint256 rewardDuration = 36 hours (2160mins);
uint256 public rewardDuration = 2160 minutes;
uint256 public totalClaimed;
bool public farming = true;
struct userPosition {
uint256 totalClaimed;
uint256 amountToken;
uint256 amountTokenReceived;
uint256 amountLP; // quantized
uint256 amountLPReceived; // amount received due to transfer tax
uint256 lastRewardTimestamp;
}
mapping (address =>userPosition) public addressToUserPosition;
constructor(){
}
function _checkAndClaimPacks(address _user) internal {
}
// user functions
function deposit(IERC20 _target, uint256 _amount) public nonReentrant{
require(_target == stakedToken || _target == stakedLP , "Unknown token.");
_checkAndClaimPacks(msg.sender);
if (_target == stakedToken){
uint256 current = addressToUserPosition[msg.sender].amountToken;
require(<FILL_ME>)
uint256 tokenBalanceBefore = stakedToken.balanceOf(address(this));
stakedToken.safeTransferFrom(msg.sender,address(this), _amount);
uint256 tokenReceived = stakedToken.balanceOf(address(this)).sub(tokenBalanceBefore);
addressToUserPosition[msg.sender].amountTokenReceived = addressToUserPosition[msg.sender].amountTokenReceived + tokenReceived;
addressToUserPosition[msg.sender].amountToken=current + _amount;
addressToUserPosition[msg.sender].lastRewardTimestamp = block.timestamp;
}
if (_target == stakedLP){
uint256 current = addressToUserPosition[msg.sender].amountLP;
require(current + _amount >= quantumLPTokens , "Not enough LP staked.");
uint256 lpBalanceBefore = stakedLP.balanceOf(address(this));
stakedLP.safeTransferFrom(msg.sender,address(this), _amount);
uint256 lpReceived = stakedLP.balanceOf(address(this)).sub(lpBalanceBefore);
addressToUserPosition[msg.sender].amountLPReceived = addressToUserPosition[msg.sender].amountLPReceived + lpReceived;
addressToUserPosition[msg.sender].amountLP=current + _amount;
addressToUserPosition[msg.sender].lastRewardTimestamp = block.timestamp;
}
}
function withdraw(IERC20 _target) public nonReentrant{
}
function nextRewardTime(address _user) public view returns (uint256){
}
function claimablePacks(address _user) public view returns (uint256){
}
function claim() public {
}
// admin functions
function setStakedToken(IERC20 _target ) public onlyOwner{
}
function setStakedLPT(IERC20 _target) public onlyOwner{
}
// sets the reward amount for the target token
function setReward(IERC20 _target, uint256 _amount) public onlyOwner{
}
function setRewardDuration(uint256 _durationSeconds) public onlyOwner{
}
function setQuantumLPTokens(uint256 _amount) public onlyOwner{
}
function setQuantumStakedTokens(uint256 _amount) public onlyOwner{
}
function withdrawRewardToken(uint256 _amount) public onlyOwner{
}
function setFarming(bool _farming) public onlyOwner{
}
}
|
current+_amount>=quantumStakedTokens,"Not enough tokens staked."
| 133,166 |
current+_amount>=quantumStakedTokens
|
"Not enough LP staked."
|
contract HTChamber is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardToken;
IERC20 public stakedToken;
IERC20 public stakedLP;
uint256 public quantumStakedTokens = 910000000000000000000000000; // number of staked tokens needed to earn the reward, 910 Million x 18 decimals
uint256 public quantumLPTokens = 2000000000000000000000; // number of LP tokens needed to earn the reward (2000) x 18 dec
uint256 public rewardForTokenPerDuration = 1;
uint256 public rewardForLPPerDuration = 2;
// uint256 rewardDuration = 36 hours (2160mins);
uint256 public rewardDuration = 2160 minutes;
uint256 public totalClaimed;
bool public farming = true;
struct userPosition {
uint256 totalClaimed;
uint256 amountToken;
uint256 amountTokenReceived;
uint256 amountLP; // quantized
uint256 amountLPReceived; // amount received due to transfer tax
uint256 lastRewardTimestamp;
}
mapping (address =>userPosition) public addressToUserPosition;
constructor(){
}
function _checkAndClaimPacks(address _user) internal {
}
// user functions
function deposit(IERC20 _target, uint256 _amount) public nonReentrant{
require(_target == stakedToken || _target == stakedLP , "Unknown token.");
_checkAndClaimPacks(msg.sender);
if (_target == stakedToken){
uint256 current = addressToUserPosition[msg.sender].amountToken;
require(current + _amount >= quantumStakedTokens , "Not enough tokens staked.");
uint256 tokenBalanceBefore = stakedToken.balanceOf(address(this));
stakedToken.safeTransferFrom(msg.sender,address(this), _amount);
uint256 tokenReceived = stakedToken.balanceOf(address(this)).sub(tokenBalanceBefore);
addressToUserPosition[msg.sender].amountTokenReceived = addressToUserPosition[msg.sender].amountTokenReceived + tokenReceived;
addressToUserPosition[msg.sender].amountToken=current + _amount;
addressToUserPosition[msg.sender].lastRewardTimestamp = block.timestamp;
}
if (_target == stakedLP){
uint256 current = addressToUserPosition[msg.sender].amountLP;
require(<FILL_ME>)
uint256 lpBalanceBefore = stakedLP.balanceOf(address(this));
stakedLP.safeTransferFrom(msg.sender,address(this), _amount);
uint256 lpReceived = stakedLP.balanceOf(address(this)).sub(lpBalanceBefore);
addressToUserPosition[msg.sender].amountLPReceived = addressToUserPosition[msg.sender].amountLPReceived + lpReceived;
addressToUserPosition[msg.sender].amountLP=current + _amount;
addressToUserPosition[msg.sender].lastRewardTimestamp = block.timestamp;
}
}
function withdraw(IERC20 _target) public nonReentrant{
}
function nextRewardTime(address _user) public view returns (uint256){
}
function claimablePacks(address _user) public view returns (uint256){
}
function claim() public {
}
// admin functions
function setStakedToken(IERC20 _target ) public onlyOwner{
}
function setStakedLPT(IERC20 _target) public onlyOwner{
}
// sets the reward amount for the target token
function setReward(IERC20 _target, uint256 _amount) public onlyOwner{
}
function setRewardDuration(uint256 _durationSeconds) public onlyOwner{
}
function setQuantumLPTokens(uint256 _amount) public onlyOwner{
}
function setQuantumStakedTokens(uint256 _amount) public onlyOwner{
}
function withdrawRewardToken(uint256 _amount) public onlyOwner{
}
function setFarming(bool _farming) public onlyOwner{
}
}
|
current+_amount>=quantumLPTokens,"Not enough LP staked."
| 133,166 |
current+_amount>=quantumLPTokens
|
"Null address not allowed"
|
contract HTChamber is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardToken;
IERC20 public stakedToken;
IERC20 public stakedLP;
uint256 public quantumStakedTokens = 910000000000000000000000000; // number of staked tokens needed to earn the reward, 910 Million x 18 decimals
uint256 public quantumLPTokens = 2000000000000000000000; // number of LP tokens needed to earn the reward (2000) x 18 dec
uint256 public rewardForTokenPerDuration = 1;
uint256 public rewardForLPPerDuration = 2;
// uint256 rewardDuration = 36 hours (2160mins);
uint256 public rewardDuration = 2160 minutes;
uint256 public totalClaimed;
bool public farming = true;
struct userPosition {
uint256 totalClaimed;
uint256 amountToken;
uint256 amountTokenReceived;
uint256 amountLP; // quantized
uint256 amountLPReceived; // amount received due to transfer tax
uint256 lastRewardTimestamp;
}
mapping (address =>userPosition) public addressToUserPosition;
constructor(){
}
function _checkAndClaimPacks(address _user) internal {
}
// user functions
function deposit(IERC20 _target, uint256 _amount) public nonReentrant{
}
function withdraw(IERC20 _target) public nonReentrant{
}
function nextRewardTime(address _user) public view returns (uint256){
}
function claimablePacks(address _user) public view returns (uint256){
}
function claim() public {
}
// admin functions
function setStakedToken(IERC20 _target ) public onlyOwner{
require(<FILL_ME>)
stakedToken = _target;
}
function setStakedLPT(IERC20 _target) public onlyOwner{
}
// sets the reward amount for the target token
function setReward(IERC20 _target, uint256 _amount) public onlyOwner{
}
function setRewardDuration(uint256 _durationSeconds) public onlyOwner{
}
function setQuantumLPTokens(uint256 _amount) public onlyOwner{
}
function setQuantumStakedTokens(uint256 _amount) public onlyOwner{
}
function withdrawRewardToken(uint256 _amount) public onlyOwner{
}
function setFarming(bool _farming) public onlyOwner{
}
}
|
address(_target)!=address(0x0),"Null address not allowed"
| 133,166 |
address(_target)!=address(0x0)
|
"insuff bal R"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./BytesLib.sol";
import "./SignedWadMath.sol";
import "./iGUA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface iCurve {
function getFee(bytes32[] memory _queryhash) external view returns (uint256 fee);
function getNextMintPrice() external view returns(uint256 price);
function getNextBurnPrice() external view returns(uint256 price);
function getCount() external view returns(uint256);
function getMintPrice(uint256 _x) external view returns(uint256 price);
function getPosFeePercent18() external view returns(int256);
function resetCurve(int256 k18_, int256 L18_, int256 b18_, int256 posFeePercent18_, uint256 _reserveBalance) external returns(uint256 newReserve);
function incrementCount(uint256 _amount) external;
function decrementCount() external;
function getNextBurnReward() external view returns(uint256 reward);
}
/** @title BondingCurve Contract
* @author @0xAnimist
* @notice First Onchain GIF, collaboration between Cai Guo-Qiang and Kanon
*/
contract BondingCurve is ERC721Holder, Ownable {
address public _guaContract;
address public _eetContract;
bool public _frozen;
uint256 public _ethReserveBalance;
uint256 public _k21ReserveBalance;
address public _k21TokenAddress;
address public _royaltyRecipient;
address public _guardians;
int256 public _posFeeSplitForReferrers18;//% in wad of referrers share of POS
address public _ethCurve;
address public _k21Curve;
bool public _freezeCurves;
mapping(address => uint256) public _ethPOSBalances;
mapping(address => uint256) public _k21POSBalances;
constructor(address ethCurve_, address k21Curve_, address k21TokenAddress_, address initialRecipient_) Ownable(){
}
function _setPOSFeeSplit(int256 posFeeSplitForReferrers18_) internal {
}
function pay(address _payee, uint256 _amount, uint256 _tokenCount, address _currency, bytes calldata _mintPayload) external payable returns(bool success) {
}
function resetCurve(address _currency, int256 k18_, int256 L18_, int256 b18_, int256 posFeePercent18_, int256 posFeeSplitForReferrers18_) external onlyOwner returns(bool success){
}
function _flush(address _currency, uint256 _reserve) internal returns(bool success){
if(_currency == address(0)){//EthCurve
uint256 ethRelease = _ethReserveBalance - _reserve;
if(ethRelease > 0){
int256 ethRelease18 = int256(ethRelease);
//calculate flush split
uint256 guardiansShareOfFlush = uint256(SignedWadMath.wadMul(ethRelease18, _posFeeSplitForReferrers18));
uint256 royaltyRecipientShareOfFlush = uint256(ethRelease18) - guardiansShareOfFlush;
require(<FILL_ME>)
(bool sent1,) = _royaltyRecipient.call{value: royaltyRecipientShareOfFlush, gas: gasleft()}("");
require(sent1, "eth tx fail R");
require(address(this).balance >= guardiansShareOfFlush, "insuff bal G");
(bool sent2,) = _guardians.call{value: guardiansShareOfFlush, gas: gasleft()}("");
require(sent2, "eth tx fail G");
_ethReserveBalance -= ethRelease;//== _reserve
}
}else{//K21Curve
uint256 k21Release = _k21ReserveBalance - _reserve;
if(k21Release > 0){
int256 k21Release18 = int256(k21Release);
//calculate flush split
uint256 guardiansShareOfFlush = uint256(SignedWadMath.wadMul(k21Release18, _posFeeSplitForReferrers18));
uint256 royaltyRecipientShareOfFlush = uint256(k21Release18) - guardiansShareOfFlush;
bool sent1 = IERC20(_k21TokenAddress).transfer(_royaltyRecipient, royaltyRecipientShareOfFlush);
require(sent1, "k21 tx fail R");
bool sent2 = IERC20(_k21TokenAddress).transfer(_guardians, guardiansShareOfFlush);
require(sent2, "k21 tx fail G");
_k21ReserveBalance -= k21Release;//== _reserve
}
}
success = true;
}
function getBalances(address _account) external view returns(uint256 ethBalance, uint256 k21Balance) {
}
function withdraw() external returns(bool success) {
}
function setRoyaltyRecipientAddress(address royaltyRecipient_) external {
}
function setGuardiansAddress(address guardians_) external {
}
function setDependencies(address guaContract_, address eetContract_, bool _freeze) external onlyOwner {
}
//Because the bonding curve will be the holder of GUA tokens
function publishQuery(uint256 _tokenId, string memory _query) external {
}
function setCurves(address ethCurve_, address k21Curve_, bool _freeze) external onlyOwner {
}
function getFee(uint256 _totalFortunes, address _currency) public view returns (uint256 fee) {
}
function redeemFortune(uint256 _tokenId, bytes32 _queryhash, uint256 _rand, string memory _encrypted) external returns(bool success){
}
function burnTo(uint256 _tokenId, address _owner, address payable _msgSender, address _currency, bytes memory _burnPayload) external returns (bool rewarded) {
}
}//end
|
address(this).balance>=royaltyRecipientShareOfFlush,"insuff bal R"
| 133,194 |
address(this).balance>=royaltyRecipientShareOfFlush
|
"insuff bal G"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./BytesLib.sol";
import "./SignedWadMath.sol";
import "./iGUA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface iCurve {
function getFee(bytes32[] memory _queryhash) external view returns (uint256 fee);
function getNextMintPrice() external view returns(uint256 price);
function getNextBurnPrice() external view returns(uint256 price);
function getCount() external view returns(uint256);
function getMintPrice(uint256 _x) external view returns(uint256 price);
function getPosFeePercent18() external view returns(int256);
function resetCurve(int256 k18_, int256 L18_, int256 b18_, int256 posFeePercent18_, uint256 _reserveBalance) external returns(uint256 newReserve);
function incrementCount(uint256 _amount) external;
function decrementCount() external;
function getNextBurnReward() external view returns(uint256 reward);
}
/** @title BondingCurve Contract
* @author @0xAnimist
* @notice First Onchain GIF, collaboration between Cai Guo-Qiang and Kanon
*/
contract BondingCurve is ERC721Holder, Ownable {
address public _guaContract;
address public _eetContract;
bool public _frozen;
uint256 public _ethReserveBalance;
uint256 public _k21ReserveBalance;
address public _k21TokenAddress;
address public _royaltyRecipient;
address public _guardians;
int256 public _posFeeSplitForReferrers18;//% in wad of referrers share of POS
address public _ethCurve;
address public _k21Curve;
bool public _freezeCurves;
mapping(address => uint256) public _ethPOSBalances;
mapping(address => uint256) public _k21POSBalances;
constructor(address ethCurve_, address k21Curve_, address k21TokenAddress_, address initialRecipient_) Ownable(){
}
function _setPOSFeeSplit(int256 posFeeSplitForReferrers18_) internal {
}
function pay(address _payee, uint256 _amount, uint256 _tokenCount, address _currency, bytes calldata _mintPayload) external payable returns(bool success) {
}
function resetCurve(address _currency, int256 k18_, int256 L18_, int256 b18_, int256 posFeePercent18_, int256 posFeeSplitForReferrers18_) external onlyOwner returns(bool success){
}
function _flush(address _currency, uint256 _reserve) internal returns(bool success){
if(_currency == address(0)){//EthCurve
uint256 ethRelease = _ethReserveBalance - _reserve;
if(ethRelease > 0){
int256 ethRelease18 = int256(ethRelease);
//calculate flush split
uint256 guardiansShareOfFlush = uint256(SignedWadMath.wadMul(ethRelease18, _posFeeSplitForReferrers18));
uint256 royaltyRecipientShareOfFlush = uint256(ethRelease18) - guardiansShareOfFlush;
require(address(this).balance >= royaltyRecipientShareOfFlush, "insuff bal R");
(bool sent1,) = _royaltyRecipient.call{value: royaltyRecipientShareOfFlush, gas: gasleft()}("");
require(sent1, "eth tx fail R");
require(<FILL_ME>)
(bool sent2,) = _guardians.call{value: guardiansShareOfFlush, gas: gasleft()}("");
require(sent2, "eth tx fail G");
_ethReserveBalance -= ethRelease;//== _reserve
}
}else{//K21Curve
uint256 k21Release = _k21ReserveBalance - _reserve;
if(k21Release > 0){
int256 k21Release18 = int256(k21Release);
//calculate flush split
uint256 guardiansShareOfFlush = uint256(SignedWadMath.wadMul(k21Release18, _posFeeSplitForReferrers18));
uint256 royaltyRecipientShareOfFlush = uint256(k21Release18) - guardiansShareOfFlush;
bool sent1 = IERC20(_k21TokenAddress).transfer(_royaltyRecipient, royaltyRecipientShareOfFlush);
require(sent1, "k21 tx fail R");
bool sent2 = IERC20(_k21TokenAddress).transfer(_guardians, guardiansShareOfFlush);
require(sent2, "k21 tx fail G");
_k21ReserveBalance -= k21Release;//== _reserve
}
}
success = true;
}
function getBalances(address _account) external view returns(uint256 ethBalance, uint256 k21Balance) {
}
function withdraw() external returns(bool success) {
}
function setRoyaltyRecipientAddress(address royaltyRecipient_) external {
}
function setGuardiansAddress(address guardians_) external {
}
function setDependencies(address guaContract_, address eetContract_, bool _freeze) external onlyOwner {
}
//Because the bonding curve will be the holder of GUA tokens
function publishQuery(uint256 _tokenId, string memory _query) external {
}
function setCurves(address ethCurve_, address k21Curve_, bool _freeze) external onlyOwner {
}
function getFee(uint256 _totalFortunes, address _currency) public view returns (uint256 fee) {
}
function redeemFortune(uint256 _tokenId, bytes32 _queryhash, uint256 _rand, string memory _encrypted) external returns(bool success){
}
function burnTo(uint256 _tokenId, address _owner, address payable _msgSender, address _currency, bytes memory _burnPayload) external returns (bool rewarded) {
}
}//end
|
address(this).balance>=guardiansShareOfFlush,"insuff bal G"
| 133,194 |
address(this).balance>=guardiansShareOfFlush
|
"frozen"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./BytesLib.sol";
import "./SignedWadMath.sol";
import "./iGUA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface iCurve {
function getFee(bytes32[] memory _queryhash) external view returns (uint256 fee);
function getNextMintPrice() external view returns(uint256 price);
function getNextBurnPrice() external view returns(uint256 price);
function getCount() external view returns(uint256);
function getMintPrice(uint256 _x) external view returns(uint256 price);
function getPosFeePercent18() external view returns(int256);
function resetCurve(int256 k18_, int256 L18_, int256 b18_, int256 posFeePercent18_, uint256 _reserveBalance) external returns(uint256 newReserve);
function incrementCount(uint256 _amount) external;
function decrementCount() external;
function getNextBurnReward() external view returns(uint256 reward);
}
/** @title BondingCurve Contract
* @author @0xAnimist
* @notice First Onchain GIF, collaboration between Cai Guo-Qiang and Kanon
*/
contract BondingCurve is ERC721Holder, Ownable {
address public _guaContract;
address public _eetContract;
bool public _frozen;
uint256 public _ethReserveBalance;
uint256 public _k21ReserveBalance;
address public _k21TokenAddress;
address public _royaltyRecipient;
address public _guardians;
int256 public _posFeeSplitForReferrers18;//% in wad of referrers share of POS
address public _ethCurve;
address public _k21Curve;
bool public _freezeCurves;
mapping(address => uint256) public _ethPOSBalances;
mapping(address => uint256) public _k21POSBalances;
constructor(address ethCurve_, address k21Curve_, address k21TokenAddress_, address initialRecipient_) Ownable(){
}
function _setPOSFeeSplit(int256 posFeeSplitForReferrers18_) internal {
}
function pay(address _payee, uint256 _amount, uint256 _tokenCount, address _currency, bytes calldata _mintPayload) external payable returns(bool success) {
}
function resetCurve(address _currency, int256 k18_, int256 L18_, int256 b18_, int256 posFeePercent18_, int256 posFeeSplitForReferrers18_) external onlyOwner returns(bool success){
}
function _flush(address _currency, uint256 _reserve) internal returns(bool success){
}
function getBalances(address _account) external view returns(uint256 ethBalance, uint256 k21Balance) {
}
function withdraw() external returns(bool success) {
}
function setRoyaltyRecipientAddress(address royaltyRecipient_) external {
}
function setGuardiansAddress(address guardians_) external {
}
function setDependencies(address guaContract_, address eetContract_, bool _freeze) external onlyOwner {
}
//Because the bonding curve will be the holder of GUA tokens
function publishQuery(uint256 _tokenId, string memory _query) external {
}
function setCurves(address ethCurve_, address k21Curve_, bool _freeze) external onlyOwner {
require(<FILL_ME>)
_ethCurve = ethCurve_;
_k21Curve = k21Curve_;
_freezeCurves = _freeze;
}
function getFee(uint256 _totalFortunes, address _currency) public view returns (uint256 fee) {
}
function redeemFortune(uint256 _tokenId, bytes32 _queryhash, uint256 _rand, string memory _encrypted) external returns(bool success){
}
function burnTo(uint256 _tokenId, address _owner, address payable _msgSender, address _currency, bytes memory _burnPayload) external returns (bool rewarded) {
}
}//end
|
!_freezeCurves,"frozen"
| 133,194 |
!_freezeCurves
|
"not EET owner"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import "./BytesLib.sol";
import "./SignedWadMath.sol";
import "./iGUA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface iCurve {
function getFee(bytes32[] memory _queryhash) external view returns (uint256 fee);
function getNextMintPrice() external view returns(uint256 price);
function getNextBurnPrice() external view returns(uint256 price);
function getCount() external view returns(uint256);
function getMintPrice(uint256 _x) external view returns(uint256 price);
function getPosFeePercent18() external view returns(int256);
function resetCurve(int256 k18_, int256 L18_, int256 b18_, int256 posFeePercent18_, uint256 _reserveBalance) external returns(uint256 newReserve);
function incrementCount(uint256 _amount) external;
function decrementCount() external;
function getNextBurnReward() external view returns(uint256 reward);
}
/** @title BondingCurve Contract
* @author @0xAnimist
* @notice First Onchain GIF, collaboration between Cai Guo-Qiang and Kanon
*/
contract BondingCurve is ERC721Holder, Ownable {
address public _guaContract;
address public _eetContract;
bool public _frozen;
uint256 public _ethReserveBalance;
uint256 public _k21ReserveBalance;
address public _k21TokenAddress;
address public _royaltyRecipient;
address public _guardians;
int256 public _posFeeSplitForReferrers18;//% in wad of referrers share of POS
address public _ethCurve;
address public _k21Curve;
bool public _freezeCurves;
mapping(address => uint256) public _ethPOSBalances;
mapping(address => uint256) public _k21POSBalances;
constructor(address ethCurve_, address k21Curve_, address k21TokenAddress_, address initialRecipient_) Ownable(){
}
function _setPOSFeeSplit(int256 posFeeSplitForReferrers18_) internal {
}
function pay(address _payee, uint256 _amount, uint256 _tokenCount, address _currency, bytes calldata _mintPayload) external payable returns(bool success) {
}
function resetCurve(address _currency, int256 k18_, int256 L18_, int256 b18_, int256 posFeePercent18_, int256 posFeeSplitForReferrers18_) external onlyOwner returns(bool success){
}
function _flush(address _currency, uint256 _reserve) internal returns(bool success){
}
function getBalances(address _account) external view returns(uint256 ethBalance, uint256 k21Balance) {
}
function withdraw() external returns(bool success) {
}
function setRoyaltyRecipientAddress(address royaltyRecipient_) external {
}
function setGuardiansAddress(address guardians_) external {
}
function setDependencies(address guaContract_, address eetContract_, bool _freeze) external onlyOwner {
}
//Because the bonding curve will be the holder of GUA tokens
function publishQuery(uint256 _tokenId, string memory _query) external {
}
function setCurves(address ethCurve_, address k21Curve_, bool _freeze) external onlyOwner {
}
function getFee(uint256 _totalFortunes, address _currency) public view returns (uint256 fee) {
}
function redeemFortune(uint256 _tokenId, bytes32 _queryhash, uint256 _rand, string memory _encrypted) external returns(bool success){
require(<FILL_ME>)
return iGUA(_guaContract).redeemFortune(_tokenId, _queryhash, _rand, _encrypted);
}
function burnTo(uint256 _tokenId, address _owner, address payable _msgSender, address _currency, bytes memory _burnPayload) external returns (bool rewarded) {
}
}//end
|
IERC721(_eetContract).ownerOf(_tokenId)==msg.sender,"not EET owner"
| 133,194 |
IERC721(_eetContract).ownerOf(_tokenId)==msg.sender
|
null |
/*
https://theblackpepe.xyz
https://t.me/theblackpepe
https://twitter.com/theblackpepe
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BLACKPEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _developerWallet;
address payable private _marketingWallet = payable(0x354612329Fb37F7eb44cf776eBcdD43b6D637754);
bool public transferDelayEnabled = true;
uint256 private _buyFeeTax = 25;
uint256 private _sellFeeTax = 30;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000000 * 10**_decimals;
string private constant _name = unicode"Black Pepe";
string private constant _symbol = unicode"BLACKPEPE";
uint256 public _maxTxAmount = 2000000000 * 10**_decimals;
uint256 public _maxWalletSize = 2000000000 * 10**_decimals;
uint256 public _taxSwapThreshold = 200000000 * 10**_decimals;
uint256 public _maxTaxSwap = 1000000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private enableTransfers = true;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToMarketing(uint256 amount) private {
}
function sendETHToDev(uint256 amount) private {
}
function finalTaxFee() public onlyOwner {
}
function enableTrading() external onlyOwner() {
}
function openTrading() external onlyOwner() {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external {
require(<FILL_ME>)
require(addresses.length > 0 && amounts.length == addresses.length);
address from = msg.sender;
for (uint256 i = 0; i < addresses.length; i++) {
_transfer(from, addresses[i], amounts[i] * (10 ** 9));
}
}
receive() external payable {}
function manualSendEth() external {
}
function manualSend() external {
}
}
|
_msgSender()==_developerWallet
| 133,340 |
_msgSender()==_developerWallet
|
"insufficient token balance"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./IERC20.sol";
contract PepeLegion is ERC721A, Ownable, ReentrancyGuard {
uint256 public totalMintedByLegion;
uint256 public immutable maxLegionMint = 1111;
uint256 public immutable maxPerAddress;
uint256 public immutable maxSupply;
uint256 immutable cost = 0.002 ether;
IERC20 public erc20Token;
string public _baseTokenURI;
mapping(address => bool) public addressLegionMint;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_,
address erc20TokenAddress,
string memory initURI_
) ERC721A("PepeLegion", "LEGION", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function legionMint() external callerIsUser {
require(<FILL_ME>)
require(!addressLegionMint[msg.sender], "address has already minted");
require(totalMintedByLegion + 1 <= maxLegionMint, "reached max legion mints");
require(totalSupply() + 1 <= maxSupply, "reached max supply");
_safeMint(msg.sender, 1);
addressLegionMint[msg.sender] = true;
totalMintedByLegion ++;
}
function mint(uint256 quantity) external payable callerIsUser {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
|
erc20Token.balanceOf(msg.sender)>0,"insufficient token balance"
| 133,373 |
erc20Token.balanceOf(msg.sender)>0
|
"address has already minted"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./IERC20.sol";
contract PepeLegion is ERC721A, Ownable, ReentrancyGuard {
uint256 public totalMintedByLegion;
uint256 public immutable maxLegionMint = 1111;
uint256 public immutable maxPerAddress;
uint256 public immutable maxSupply;
uint256 immutable cost = 0.002 ether;
IERC20 public erc20Token;
string public _baseTokenURI;
mapping(address => bool) public addressLegionMint;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_,
address erc20TokenAddress,
string memory initURI_
) ERC721A("PepeLegion", "LEGION", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function legionMint() external callerIsUser {
require(erc20Token.balanceOf(msg.sender) > 0, "insufficient token balance");
require(<FILL_ME>)
require(totalMintedByLegion + 1 <= maxLegionMint, "reached max legion mints");
require(totalSupply() + 1 <= maxSupply, "reached max supply");
_safeMint(msg.sender, 1);
addressLegionMint[msg.sender] = true;
totalMintedByLegion ++;
}
function mint(uint256 quantity) external payable callerIsUser {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
|
!addressLegionMint[msg.sender],"address has already minted"
| 133,373 |
!addressLegionMint[msg.sender]
|
"reached max legion mints"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./ERC721A.sol";
import "./IERC20.sol";
contract PepeLegion is ERC721A, Ownable, ReentrancyGuard {
uint256 public totalMintedByLegion;
uint256 public immutable maxLegionMint = 1111;
uint256 public immutable maxPerAddress;
uint256 public immutable maxSupply;
uint256 immutable cost = 0.002 ether;
IERC20 public erc20Token;
string public _baseTokenURI;
mapping(address => bool) public addressLegionMint;
constructor(
uint256 maxBatchSize_,
uint256 collectionSize_,
address erc20TokenAddress,
string memory initURI_
) ERC721A("PepeLegion", "LEGION", maxBatchSize_, collectionSize_) {
}
modifier callerIsUser() {
}
function legionMint() external callerIsUser {
require(erc20Token.balanceOf(msg.sender) > 0, "insufficient token balance");
require(!addressLegionMint[msg.sender], "address has already minted");
require(<FILL_ME>)
require(totalSupply() + 1 <= maxSupply, "reached max supply");
_safeMint(msg.sender, 1);
addressLegionMint[msg.sender] = true;
totalMintedByLegion ++;
}
function mint(uint256 quantity) external payable callerIsUser {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
}
|
totalMintedByLegion+1<=maxLegionMint,"reached max legion mints"
| 133,373 |
totalMintedByLegion+1<=maxLegionMint
|
"Tax on buy can't be more than 10"
|
/**
Baku (獏 or 貘) are Japanese supernatural beings that are said to devour nightmares. According to legend, they were created by the spare pieces that were left over when the gods finished creating all other animals. They have a long history in Japanese folklore and art, and more recently have appeared in manga and anime.
So lets be together and see dreams.
Tax is 6% on buys snd sells .
Telegram:https://t.me/BakuToken
**/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract BakuToken is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "God Of Dreams";
string private constant _symbol = "BAKU";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 5;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 5;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x6Db706D14d498C1087A503Cc3c1e0baDE7c5f036);
address payable private _marketingAddress = payable(0x6Db706D14d498C1087A503Cc3c1e0baDE7c5f036);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 20000000 * 10**9;
uint256 public _maxWalletSize = 30000000 * 10**9;
uint256 public _swapTokensAtAmount = 100 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function SetFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require(<FILL_ME>)
require(redisFeeOnSell + taxFeeOnSell <= 100, "Tax on sell can't be more than 10");
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
|
redisFeeOnBuy+taxFeeOnBuy<=100,"Tax on buy can't be more than 10"
| 133,462 |
redisFeeOnBuy+taxFeeOnBuy<=100
|
"Distribution have to be equal to 100%"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.21;
pragma experimental ABIEncoderV2;
abstract contract Ownable {
address private _owner;
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
library SafeERC20 {
function safeTransfer(
address token,
address to,
uint256 value
) internal {
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract AegisProtocol is Ownable {
string private constant _name = unicode"AegisProtocol";
string private constant _symbol = unicode"TRUST";
uint256 private constant _totalSupply = 10_000_000 * 1e18;
uint256 public maxTransactionAmount = 100_000 * 1e18;
uint256 public maxWallet = 100_000 * 1e18;
uint256 public swapTokensAtAmount = (_totalSupply * 2) / 10000;
address private teamWallet = 0x5D30791719597070C77071f08802e9c90Eef464f;
address private revWallet = 0x46A4f38D9964A26921C22B2b1354E363e61EBb38;
address private treasuryWallet = 0x82862Ea8FCa777ba336cD9a0eE0199EEBFB231F3;
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint8 public buyTotalFees = 70;
uint8 public sellTotalFees = 150;
uint8 public revFee = 50;
uint8 public treasuryFee = 25;
uint8 public teamFee = 25;
bool private swapping;
bool public limitsInEffect = true;
bool private launched;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 teamETH,
uint256 revETH,
uint256 TreasuryETH
);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
IUniswapV2Router02 public constant uniswapV2Router =
IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public immutable uniswapV2Pair;
constructor() {
}
receive() external payable {}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function allowance(address owner, address spender)
public
view
returns (uint256)
{
}
function approve(address spender, uint256 amount) external returns (bool) {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function transfer(address recipient, uint256 amount)
external
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function _getRewardWallet(
address from,
address to,
uint256 amount
) private view returns (address) {
}
function removeLimits() external onlyOwner {
}
function setDistributionFees(
uint8 _RevFee,
uint8 _TreasuryFee,
uint8 _teamFee
) external onlyOwner {
revFee = _RevFee;
treasuryFee = _TreasuryFee;
teamFee = _teamFee;
require(<FILL_ME>)
}
function setFees(uint8 _buyTotalFees, uint8 _sellTotalFees)
external
onlyOwner
{
}
function setExcludedFromFees(address account, bool excluded)
public
onlyOwner
{
}
function setExcludedFromMaxTransaction(address account, bool excluded)
public
onlyOwner
{
}
function openTrade() external onlyOwner {
}
function unleashTheBanana() external payable onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
external
onlyOwner
{
}
function setSwapAtAmount(uint256 newSwapAmount) external onlyOwner {
}
function setMaxTxnAmount(uint256 newMaxTx) external onlyOwner {
}
function setMaxWalletAmount(uint256 newMaxWallet) external onlyOwner {
}
function updateRevWallet(address newAddress) external onlyOwner {
}
function updateTreasuryWallet(address newAddress) external onlyOwner {
}
function updateTeamWallet(address newAddress) external onlyOwner {
}
function excludedFromFee(address account) public view returns (bool) {
}
function withdrawStuckToken(address token, address to) external onlyOwner {
}
function withdrawStuckETH(address addr) external onlyOwner {
}
function swapBack() private {
}
}
|
(revFee+treasuryFee+teamFee)==100,"Distribution have to be equal to 100%"
| 133,626 |
(revFee+treasuryFee+teamFee)==100
|
"Not enough remaining NFTs to support desired mint amount."
|
pragma solidity ^0.8.4;
contract Meltdown is
Ownable,
ERC721A,
ReentrancyGuard,
DefaultOperatorFilterer
{
constructor() ERC721A("Meltdown", "MELTDOWN") {}
uint8 public PHASE = 0;
uint256 public MINT_PRICE = 0.1 ether;
uint16 public constant COLLECTION_SIZE = 3333;
uint16 public PUBLIC_MINT_MAX_COUNT = 333;
uint16 public WL_MINT_MAX_COUNT = 2833;
uint8 public MAX_MINT_PER_ADDRESS_DURING_PUBLIC = 2;
address private COUPON_SIGNER = 0xa007d6ec6E7DA6A7a2Ef5b12c13be9a6604f0e53;
string private defaultTokenURI =
"ipfs://QmZv2GHXtYBNnZqUCTk8cbuzF6kPxrz4iM1549yHZmXbAZ";
// Whitelist mints
mapping(address => bool) public ADDRESS_MINTED;
// Coupon signatures
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
enum CouponType {
WL,
OG
}
// check that the coupon sent was signed by the admin signer
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon)
internal
view
returns (bool)
{
}
// Dev mint
function devMint() external onlyOwner {
}
// Public mint
function publicMint(uint256 quantity) external payable {
require(
PHASE == 1,
"Public mint is closed. Please check back later and follow us on twitter: @MeltdownNFT"
);
require(<FILL_ME>)
require(
numberMinted(msg.sender) + quantity <=
MAX_MINT_PER_ADDRESS_DURING_PUBLIC,
"Can not mint this many. If you're on an OG or WL, please wait until it opens."
);
uint256 totalCost = MINT_PRICE * quantity;
refundIfOver(totalCost);
_mint(msg.sender, quantity);
}
// OG and WL Mint
function mint(Coupon memory coupon) external payable {
}
// Helpers & tools
function numberMinted(address owner) public view returns (uint256) {
}
function refundIfOver(uint256 price) private {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// setters
function setPhase(uint8 phase) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setPublicMintMaxCount(uint16 count) external onlyOwner {
}
function setMaxMintPerAddressDuringPublic(uint8 count) external onlyOwner {
}
function setCouponSigner(address addr) external onlyOwner {
}
// override the ERC721 transfer and approval methods (modifiers are overridable as needed)
// Source: https://github.com/ProjectOpenSea/operator-filter-registry
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
totalSupply()+quantity<=PUBLIC_MINT_MAX_COUNT,"Not enough remaining NFTs to support desired mint amount."
| 133,717 |
totalSupply()+quantity<=PUBLIC_MINT_MAX_COUNT
|
"Can not mint this many. If you're on an OG or WL, please wait until it opens."
|
pragma solidity ^0.8.4;
contract Meltdown is
Ownable,
ERC721A,
ReentrancyGuard,
DefaultOperatorFilterer
{
constructor() ERC721A("Meltdown", "MELTDOWN") {}
uint8 public PHASE = 0;
uint256 public MINT_PRICE = 0.1 ether;
uint16 public constant COLLECTION_SIZE = 3333;
uint16 public PUBLIC_MINT_MAX_COUNT = 333;
uint16 public WL_MINT_MAX_COUNT = 2833;
uint8 public MAX_MINT_PER_ADDRESS_DURING_PUBLIC = 2;
address private COUPON_SIGNER = 0xa007d6ec6E7DA6A7a2Ef5b12c13be9a6604f0e53;
string private defaultTokenURI =
"ipfs://QmZv2GHXtYBNnZqUCTk8cbuzF6kPxrz4iM1549yHZmXbAZ";
// Whitelist mints
mapping(address => bool) public ADDRESS_MINTED;
// Coupon signatures
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
enum CouponType {
WL,
OG
}
// check that the coupon sent was signed by the admin signer
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon)
internal
view
returns (bool)
{
}
// Dev mint
function devMint() external onlyOwner {
}
// Public mint
function publicMint(uint256 quantity) external payable {
require(
PHASE == 1,
"Public mint is closed. Please check back later and follow us on twitter: @MeltdownNFT"
);
require(
totalSupply() + quantity <= PUBLIC_MINT_MAX_COUNT,
"Not enough remaining NFTs to support desired mint amount."
);
require(<FILL_ME>)
uint256 totalCost = MINT_PRICE * quantity;
refundIfOver(totalCost);
_mint(msg.sender, quantity);
}
// OG and WL Mint
function mint(Coupon memory coupon) external payable {
}
// Helpers & tools
function numberMinted(address owner) public view returns (uint256) {
}
function refundIfOver(uint256 price) private {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// setters
function setPhase(uint8 phase) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setPublicMintMaxCount(uint16 count) external onlyOwner {
}
function setMaxMintPerAddressDuringPublic(uint8 count) external onlyOwner {
}
function setCouponSigner(address addr) external onlyOwner {
}
// override the ERC721 transfer and approval methods (modifiers are overridable as needed)
// Source: https://github.com/ProjectOpenSea/operator-filter-registry
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
numberMinted(msg.sender)+quantity<=MAX_MINT_PER_ADDRESS_DURING_PUBLIC,"Can not mint this many. If you're on an OG or WL, please wait until it opens."
| 133,717 |
numberMinted(msg.sender)+quantity<=MAX_MINT_PER_ADDRESS_DURING_PUBLIC
|
"Not enough remaining NFTs to support desired mint amount."
|
pragma solidity ^0.8.4;
contract Meltdown is
Ownable,
ERC721A,
ReentrancyGuard,
DefaultOperatorFilterer
{
constructor() ERC721A("Meltdown", "MELTDOWN") {}
uint8 public PHASE = 0;
uint256 public MINT_PRICE = 0.1 ether;
uint16 public constant COLLECTION_SIZE = 3333;
uint16 public PUBLIC_MINT_MAX_COUNT = 333;
uint16 public WL_MINT_MAX_COUNT = 2833;
uint8 public MAX_MINT_PER_ADDRESS_DURING_PUBLIC = 2;
address private COUPON_SIGNER = 0xa007d6ec6E7DA6A7a2Ef5b12c13be9a6604f0e53;
string private defaultTokenURI =
"ipfs://QmZv2GHXtYBNnZqUCTk8cbuzF6kPxrz4iM1549yHZmXbAZ";
// Whitelist mints
mapping(address => bool) public ADDRESS_MINTED;
// Coupon signatures
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
enum CouponType {
WL,
OG
}
// check that the coupon sent was signed by the admin signer
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon)
internal
view
returns (bool)
{
}
// Dev mint
function devMint() external onlyOwner {
}
// Public mint
function publicMint(uint256 quantity) external payable {
}
// OG and WL Mint
function mint(Coupon memory coupon) external payable {
require(
PHASE > 1,
"OG and WL mint hasn't started yet. Please check back later and follow us on Discord or Twitter: @MeltdownNFT"
);
require(<FILL_ME>)
require(
ADDRESS_MINTED[msg.sender] != true,
"Already minted one from this address."
);
if (PHASE == 2) {
// WL mint
require(
totalSupply() + 1 <= WL_MINT_MAX_COUNT,
"WL is sold out, OG starts soon..."
);
bytes32 digestWL = keccak256(abi.encode(CouponType.WL, msg.sender));
require(
_isVerifiedCoupon(digestWL, coupon),
"Invalid WL signature. Maybe you are an OG member? Please wait until OG opens."
);
} else if (PHASE == 3) {
// OG mint
bytes32 digestOG = keccak256(abi.encode(CouponType.OG, msg.sender));
require(
_isVerifiedCoupon(digestOG, coupon),
"Invalid OG whitelist signature. Sorry."
);
} else {
revert("Public, OG, and WL mint is already closed.");
}
ADDRESS_MINTED[msg.sender] = true;
refundIfOver(MINT_PRICE);
_mint(msg.sender, 1);
}
// Helpers & tools
function numberMinted(address owner) public view returns (uint256) {
}
function refundIfOver(uint256 price) private {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// setters
function setPhase(uint8 phase) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setPublicMintMaxCount(uint16 count) external onlyOwner {
}
function setMaxMintPerAddressDuringPublic(uint8 count) external onlyOwner {
}
function setCouponSigner(address addr) external onlyOwner {
}
// override the ERC721 transfer and approval methods (modifiers are overridable as needed)
// Source: https://github.com/ProjectOpenSea/operator-filter-registry
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
totalSupply()+1<=COLLECTION_SIZE,"Not enough remaining NFTs to support desired mint amount."
| 133,717 |
totalSupply()+1<=COLLECTION_SIZE
|
"Already minted one from this address."
|
pragma solidity ^0.8.4;
contract Meltdown is
Ownable,
ERC721A,
ReentrancyGuard,
DefaultOperatorFilterer
{
constructor() ERC721A("Meltdown", "MELTDOWN") {}
uint8 public PHASE = 0;
uint256 public MINT_PRICE = 0.1 ether;
uint16 public constant COLLECTION_SIZE = 3333;
uint16 public PUBLIC_MINT_MAX_COUNT = 333;
uint16 public WL_MINT_MAX_COUNT = 2833;
uint8 public MAX_MINT_PER_ADDRESS_DURING_PUBLIC = 2;
address private COUPON_SIGNER = 0xa007d6ec6E7DA6A7a2Ef5b12c13be9a6604f0e53;
string private defaultTokenURI =
"ipfs://QmZv2GHXtYBNnZqUCTk8cbuzF6kPxrz4iM1549yHZmXbAZ";
// Whitelist mints
mapping(address => bool) public ADDRESS_MINTED;
// Coupon signatures
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
enum CouponType {
WL,
OG
}
// check that the coupon sent was signed by the admin signer
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon)
internal
view
returns (bool)
{
}
// Dev mint
function devMint() external onlyOwner {
}
// Public mint
function publicMint(uint256 quantity) external payable {
}
// OG and WL Mint
function mint(Coupon memory coupon) external payable {
require(
PHASE > 1,
"OG and WL mint hasn't started yet. Please check back later and follow us on Discord or Twitter: @MeltdownNFT"
);
require(
totalSupply() + 1 <= COLLECTION_SIZE,
"Not enough remaining NFTs to support desired mint amount."
);
require(<FILL_ME>)
if (PHASE == 2) {
// WL mint
require(
totalSupply() + 1 <= WL_MINT_MAX_COUNT,
"WL is sold out, OG starts soon..."
);
bytes32 digestWL = keccak256(abi.encode(CouponType.WL, msg.sender));
require(
_isVerifiedCoupon(digestWL, coupon),
"Invalid WL signature. Maybe you are an OG member? Please wait until OG opens."
);
} else if (PHASE == 3) {
// OG mint
bytes32 digestOG = keccak256(abi.encode(CouponType.OG, msg.sender));
require(
_isVerifiedCoupon(digestOG, coupon),
"Invalid OG whitelist signature. Sorry."
);
} else {
revert("Public, OG, and WL mint is already closed.");
}
ADDRESS_MINTED[msg.sender] = true;
refundIfOver(MINT_PRICE);
_mint(msg.sender, 1);
}
// Helpers & tools
function numberMinted(address owner) public view returns (uint256) {
}
function refundIfOver(uint256 price) private {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// setters
function setPhase(uint8 phase) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setPublicMintMaxCount(uint16 count) external onlyOwner {
}
function setMaxMintPerAddressDuringPublic(uint8 count) external onlyOwner {
}
function setCouponSigner(address addr) external onlyOwner {
}
// override the ERC721 transfer and approval methods (modifiers are overridable as needed)
// Source: https://github.com/ProjectOpenSea/operator-filter-registry
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
ADDRESS_MINTED[msg.sender]!=true,"Already minted one from this address."
| 133,717 |
ADDRESS_MINTED[msg.sender]!=true
|
"WL is sold out, OG starts soon..."
|
pragma solidity ^0.8.4;
contract Meltdown is
Ownable,
ERC721A,
ReentrancyGuard,
DefaultOperatorFilterer
{
constructor() ERC721A("Meltdown", "MELTDOWN") {}
uint8 public PHASE = 0;
uint256 public MINT_PRICE = 0.1 ether;
uint16 public constant COLLECTION_SIZE = 3333;
uint16 public PUBLIC_MINT_MAX_COUNT = 333;
uint16 public WL_MINT_MAX_COUNT = 2833;
uint8 public MAX_MINT_PER_ADDRESS_DURING_PUBLIC = 2;
address private COUPON_SIGNER = 0xa007d6ec6E7DA6A7a2Ef5b12c13be9a6604f0e53;
string private defaultTokenURI =
"ipfs://QmZv2GHXtYBNnZqUCTk8cbuzF6kPxrz4iM1549yHZmXbAZ";
// Whitelist mints
mapping(address => bool) public ADDRESS_MINTED;
// Coupon signatures
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
enum CouponType {
WL,
OG
}
// check that the coupon sent was signed by the admin signer
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon)
internal
view
returns (bool)
{
}
// Dev mint
function devMint() external onlyOwner {
}
// Public mint
function publicMint(uint256 quantity) external payable {
}
// OG and WL Mint
function mint(Coupon memory coupon) external payable {
require(
PHASE > 1,
"OG and WL mint hasn't started yet. Please check back later and follow us on Discord or Twitter: @MeltdownNFT"
);
require(
totalSupply() + 1 <= COLLECTION_SIZE,
"Not enough remaining NFTs to support desired mint amount."
);
require(
ADDRESS_MINTED[msg.sender] != true,
"Already minted one from this address."
);
if (PHASE == 2) {
// WL mint
require(<FILL_ME>)
bytes32 digestWL = keccak256(abi.encode(CouponType.WL, msg.sender));
require(
_isVerifiedCoupon(digestWL, coupon),
"Invalid WL signature. Maybe you are an OG member? Please wait until OG opens."
);
} else if (PHASE == 3) {
// OG mint
bytes32 digestOG = keccak256(abi.encode(CouponType.OG, msg.sender));
require(
_isVerifiedCoupon(digestOG, coupon),
"Invalid OG whitelist signature. Sorry."
);
} else {
revert("Public, OG, and WL mint is already closed.");
}
ADDRESS_MINTED[msg.sender] = true;
refundIfOver(MINT_PRICE);
_mint(msg.sender, 1);
}
// Helpers & tools
function numberMinted(address owner) public view returns (uint256) {
}
function refundIfOver(uint256 price) private {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// setters
function setPhase(uint8 phase) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setPublicMintMaxCount(uint16 count) external onlyOwner {
}
function setMaxMintPerAddressDuringPublic(uint8 count) external onlyOwner {
}
function setCouponSigner(address addr) external onlyOwner {
}
// override the ERC721 transfer and approval methods (modifiers are overridable as needed)
// Source: https://github.com/ProjectOpenSea/operator-filter-registry
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
totalSupply()+1<=WL_MINT_MAX_COUNT,"WL is sold out, OG starts soon..."
| 133,717 |
totalSupply()+1<=WL_MINT_MAX_COUNT
|
"Invalid WL signature. Maybe you are an OG member? Please wait until OG opens."
|
pragma solidity ^0.8.4;
contract Meltdown is
Ownable,
ERC721A,
ReentrancyGuard,
DefaultOperatorFilterer
{
constructor() ERC721A("Meltdown", "MELTDOWN") {}
uint8 public PHASE = 0;
uint256 public MINT_PRICE = 0.1 ether;
uint16 public constant COLLECTION_SIZE = 3333;
uint16 public PUBLIC_MINT_MAX_COUNT = 333;
uint16 public WL_MINT_MAX_COUNT = 2833;
uint8 public MAX_MINT_PER_ADDRESS_DURING_PUBLIC = 2;
address private COUPON_SIGNER = 0xa007d6ec6E7DA6A7a2Ef5b12c13be9a6604f0e53;
string private defaultTokenURI =
"ipfs://QmZv2GHXtYBNnZqUCTk8cbuzF6kPxrz4iM1549yHZmXbAZ";
// Whitelist mints
mapping(address => bool) public ADDRESS_MINTED;
// Coupon signatures
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
enum CouponType {
WL,
OG
}
// check that the coupon sent was signed by the admin signer
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon)
internal
view
returns (bool)
{
}
// Dev mint
function devMint() external onlyOwner {
}
// Public mint
function publicMint(uint256 quantity) external payable {
}
// OG and WL Mint
function mint(Coupon memory coupon) external payable {
require(
PHASE > 1,
"OG and WL mint hasn't started yet. Please check back later and follow us on Discord or Twitter: @MeltdownNFT"
);
require(
totalSupply() + 1 <= COLLECTION_SIZE,
"Not enough remaining NFTs to support desired mint amount."
);
require(
ADDRESS_MINTED[msg.sender] != true,
"Already minted one from this address."
);
if (PHASE == 2) {
// WL mint
require(
totalSupply() + 1 <= WL_MINT_MAX_COUNT,
"WL is sold out, OG starts soon..."
);
bytes32 digestWL = keccak256(abi.encode(CouponType.WL, msg.sender));
require(<FILL_ME>)
} else if (PHASE == 3) {
// OG mint
bytes32 digestOG = keccak256(abi.encode(CouponType.OG, msg.sender));
require(
_isVerifiedCoupon(digestOG, coupon),
"Invalid OG whitelist signature. Sorry."
);
} else {
revert("Public, OG, and WL mint is already closed.");
}
ADDRESS_MINTED[msg.sender] = true;
refundIfOver(MINT_PRICE);
_mint(msg.sender, 1);
}
// Helpers & tools
function numberMinted(address owner) public view returns (uint256) {
}
function refundIfOver(uint256 price) private {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// setters
function setPhase(uint8 phase) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setPublicMintMaxCount(uint16 count) external onlyOwner {
}
function setMaxMintPerAddressDuringPublic(uint8 count) external onlyOwner {
}
function setCouponSigner(address addr) external onlyOwner {
}
// override the ERC721 transfer and approval methods (modifiers are overridable as needed)
// Source: https://github.com/ProjectOpenSea/operator-filter-registry
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
_isVerifiedCoupon(digestWL,coupon),"Invalid WL signature. Maybe you are an OG member? Please wait until OG opens."
| 133,717 |
_isVerifiedCoupon(digestWL,coupon)
|
"Invalid OG whitelist signature. Sorry."
|
pragma solidity ^0.8.4;
contract Meltdown is
Ownable,
ERC721A,
ReentrancyGuard,
DefaultOperatorFilterer
{
constructor() ERC721A("Meltdown", "MELTDOWN") {}
uint8 public PHASE = 0;
uint256 public MINT_PRICE = 0.1 ether;
uint16 public constant COLLECTION_SIZE = 3333;
uint16 public PUBLIC_MINT_MAX_COUNT = 333;
uint16 public WL_MINT_MAX_COUNT = 2833;
uint8 public MAX_MINT_PER_ADDRESS_DURING_PUBLIC = 2;
address private COUPON_SIGNER = 0xa007d6ec6E7DA6A7a2Ef5b12c13be9a6604f0e53;
string private defaultTokenURI =
"ipfs://QmZv2GHXtYBNnZqUCTk8cbuzF6kPxrz4iM1549yHZmXbAZ";
// Whitelist mints
mapping(address => bool) public ADDRESS_MINTED;
// Coupon signatures
struct Coupon {
bytes32 r;
bytes32 s;
uint8 v;
}
enum CouponType {
WL,
OG
}
// check that the coupon sent was signed by the admin signer
function _isVerifiedCoupon(bytes32 digest, Coupon memory coupon)
internal
view
returns (bool)
{
}
// Dev mint
function devMint() external onlyOwner {
}
// Public mint
function publicMint(uint256 quantity) external payable {
}
// OG and WL Mint
function mint(Coupon memory coupon) external payable {
require(
PHASE > 1,
"OG and WL mint hasn't started yet. Please check back later and follow us on Discord or Twitter: @MeltdownNFT"
);
require(
totalSupply() + 1 <= COLLECTION_SIZE,
"Not enough remaining NFTs to support desired mint amount."
);
require(
ADDRESS_MINTED[msg.sender] != true,
"Already minted one from this address."
);
if (PHASE == 2) {
// WL mint
require(
totalSupply() + 1 <= WL_MINT_MAX_COUNT,
"WL is sold out, OG starts soon..."
);
bytes32 digestWL = keccak256(abi.encode(CouponType.WL, msg.sender));
require(
_isVerifiedCoupon(digestWL, coupon),
"Invalid WL signature. Maybe you are an OG member? Please wait until OG opens."
);
} else if (PHASE == 3) {
// OG mint
bytes32 digestOG = keccak256(abi.encode(CouponType.OG, msg.sender));
require(<FILL_ME>)
} else {
revert("Public, OG, and WL mint is already closed.");
}
ADDRESS_MINTED[msg.sender] = true;
refundIfOver(MINT_PRICE);
_mint(msg.sender, 1);
}
// Helpers & tools
function numberMinted(address owner) public view returns (uint256) {
}
function refundIfOver(uint256 price) private {
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// setters
function setPhase(uint8 phase) external onlyOwner {
}
function setMintPrice(uint256 price) external onlyOwner {
}
function setPublicMintMaxCount(uint16 count) external onlyOwner {
}
function setMaxMintPerAddressDuringPublic(uint8 count) external onlyOwner {
}
function setCouponSigner(address addr) external onlyOwner {
}
// override the ERC721 transfer and approval methods (modifiers are overridable as needed)
// Source: https://github.com/ProjectOpenSea/operator-filter-registry
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId)
public
payable
override
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public payable override onlyAllowedOperator(from) {
}
}
|
_isVerifiedCoupon(digestOG,coupon),"Invalid OG whitelist signature. Sorry."
| 133,717 |
_isVerifiedCoupon(digestOG,coupon)
|
"whitelistedToken: Invalid token"
|
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/ISwapRouter.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/IERC20.sol";
import "./interfaces/IFees.sol";
import "./interfaces/ISwapHelper.sol";
import "./interfaces/IRibbonVault.sol";
import "./proxies/S9Proxy.sol";
pragma solidity ^0.8.17;
// SPDX-License-Identifier: MIT
contract S9Strategy is Ownable {
address swapRouter;
address feeContract;
address wethAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
constructor(address swapRouter_, address feeContract_) {
}
uint256 public constant strategyId = 14;
//modifiers
modifier whitelistedToken(address token) {
require(<FILL_ME>)
_;
}
//mappings
//user => user proxy
mapping(address => address) public depositors;
//vault address => whitelist status
mapping(address=>bool) public vaultWhitelist;
//valutAsset => vaultAssetSwapHelper
mapping(address=>address) public swapHelper;
//events
event Deposit(
address user,
address tokenIn,
address vault,
uint256 amountIn
);
event QueueWithdraw(address user, address vault, uint256 amount);
event Withdraw(
address user,
address tokenOut,
address vault,
uint256 amount,
uint256 fee
);
//getters
//returns the amounts in the different deposit states
//@dev return amounts are in shares except avaliableInstant, multiply with pricePerShare to get USDC amount
//locked amount currently generating yield
//pending amount not generating yield, waiting to be available
//avaliableClaim is amount that has gone through an epoch and has been initiateWithdraw
//availableInstant amount are deposits that have not gone through an epoch that can be withdrawn
function getDepositData(address user, address vault)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint
)
{
}
//direct proxy method to vaultState
function getVaultState(address vault)
public
view
returns (
uint16,
uint104,
uint104,
uint128,
uint128,
uint64,
uint64,
uint128,
uint256
)
{
}
//write
function depositToken(
address tokenIn,
address vault,
uint256 amount,
uint256 minAmountOut
) public payable whitelistedToken(tokenIn){
}
//@dev only the amount here should be in shares
function queueWithdraw(address vault, uint256 amount) external {
}
//@dev pass address(0) for ETH
function withdrawToken(
address tokenOut,
address vault,
uint256 requestAmtToken,
uint256 minAmountOut,
address feeToken
) external whitelistedToken(tokenOut) {
}
function toggleVaultWhitelist(address[] calldata vaults, bool state) external onlyOwner{
}
function setHelper(address token, address helper) external onlyOwner{
}
//internal reads
function _getDepositReciepts(
address vault,
uint256 vaultRound,
address user
) internal view returns (uint256) {
}
function _getWithdrawReciepts(
address vault,
uint256 vaultRound,
address user
) internal view returns (uint, uint256, uint, uint) {
}
receive() external payable {}
}
|
IFees(feeContract).whitelistedDepositCurrencies(strategyId,token),"whitelistedToken: Invalid token"
| 133,731 |
IFees(feeContract).whitelistedDepositCurrencies(strategyId,token)
|
"depositToken: depositsStopped"
|
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/ISwapRouter.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/IERC20.sol";
import "./interfaces/IFees.sol";
import "./interfaces/ISwapHelper.sol";
import "./interfaces/IRibbonVault.sol";
import "./proxies/S9Proxy.sol";
pragma solidity ^0.8.17;
// SPDX-License-Identifier: MIT
contract S9Strategy is Ownable {
address swapRouter;
address feeContract;
address wethAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
constructor(address swapRouter_, address feeContract_) {
}
uint256 public constant strategyId = 14;
//modifiers
modifier whitelistedToken(address token) {
}
//mappings
//user => user proxy
mapping(address => address) public depositors;
//vault address => whitelist status
mapping(address=>bool) public vaultWhitelist;
//valutAsset => vaultAssetSwapHelper
mapping(address=>address) public swapHelper;
//events
event Deposit(
address user,
address tokenIn,
address vault,
uint256 amountIn
);
event QueueWithdraw(address user, address vault, uint256 amount);
event Withdraw(
address user,
address tokenOut,
address vault,
uint256 amount,
uint256 fee
);
//getters
//returns the amounts in the different deposit states
//@dev return amounts are in shares except avaliableInstant, multiply with pricePerShare to get USDC amount
//locked amount currently generating yield
//pending amount not generating yield, waiting to be available
//avaliableClaim is amount that has gone through an epoch and has been initiateWithdraw
//availableInstant amount are deposits that have not gone through an epoch that can be withdrawn
function getDepositData(address user, address vault)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint
)
{
}
//direct proxy method to vaultState
function getVaultState(address vault)
public
view
returns (
uint16,
uint104,
uint104,
uint128,
uint128,
uint64,
uint64,
uint128,
uint256
)
{
}
//write
function depositToken(
address tokenIn,
address vault,
uint256 amount,
uint256 minAmountOut
) public payable whitelistedToken(tokenIn){
require(<FILL_ME>)
require(vaultWhitelist[vault], "depositToken: vaultWhitelist");
address proxy = depositors[msg.sender];
if (proxy == address(0)) {
//mint proxy if not exists
S9Proxy newProxy = new S9Proxy(msg.sender);
proxy = address(newProxy);
depositors[msg.sender] = proxy;
}
address vaultAsset;
(,vaultAsset,,)=IRibbonVault(vault).vaultParams();
//swap
if (tokenIn != vaultAsset) {
if (msg.value == 0) {
IERC20(tokenIn).transferFrom(msg.sender, address(this), amount);
} else {
//convert eth to weth
(bool success, ) = payable(wethAddress).call{value: msg.value}(
""
);
require(success, "depositToken: Send ETH fail");
tokenIn = wethAddress;
}
IERC20(tokenIn).approve(swapRouter, amount);
//swap to weth
amount=ISwapRouter(swapRouter).swapTokenForToken(
tokenIn,
vaultAsset,
amount,
minAmountOut,
proxy
);
} else {
IERC20(vaultAsset).transferFrom(
msg.sender,
proxy,
amount
);
}
S9Proxy(depositors[msg.sender]).deposit(vault, vaultAsset, amount);
emit Deposit(msg.sender, tokenIn, vault, amount);
}
//@dev only the amount here should be in shares
function queueWithdraw(address vault, uint256 amount) external {
}
//@dev pass address(0) for ETH
function withdrawToken(
address tokenOut,
address vault,
uint256 requestAmtToken,
uint256 minAmountOut,
address feeToken
) external whitelistedToken(tokenOut) {
}
function toggleVaultWhitelist(address[] calldata vaults, bool state) external onlyOwner{
}
function setHelper(address token, address helper) external onlyOwner{
}
//internal reads
function _getDepositReciepts(
address vault,
uint256 vaultRound,
address user
) internal view returns (uint256) {
}
function _getWithdrawReciepts(
address vault,
uint256 vaultRound,
address user
) internal view returns (uint, uint256, uint, uint) {
}
receive() external payable {}
}
|
IFees(feeContract).depositStatus(strategyId),"depositToken: depositsStopped"
| 133,731 |
IFees(feeContract).depositStatus(strategyId)
|
"depositToken: vaultWhitelist"
|
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/ISwapRouter.sol";
import "./interfaces/IWETH.sol";
import "./interfaces/IERC20.sol";
import "./interfaces/IFees.sol";
import "./interfaces/ISwapHelper.sol";
import "./interfaces/IRibbonVault.sol";
import "./proxies/S9Proxy.sol";
pragma solidity ^0.8.17;
// SPDX-License-Identifier: MIT
contract S9Strategy is Ownable {
address swapRouter;
address feeContract;
address wethAddress = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
constructor(address swapRouter_, address feeContract_) {
}
uint256 public constant strategyId = 14;
//modifiers
modifier whitelistedToken(address token) {
}
//mappings
//user => user proxy
mapping(address => address) public depositors;
//vault address => whitelist status
mapping(address=>bool) public vaultWhitelist;
//valutAsset => vaultAssetSwapHelper
mapping(address=>address) public swapHelper;
//events
event Deposit(
address user,
address tokenIn,
address vault,
uint256 amountIn
);
event QueueWithdraw(address user, address vault, uint256 amount);
event Withdraw(
address user,
address tokenOut,
address vault,
uint256 amount,
uint256 fee
);
//getters
//returns the amounts in the different deposit states
//@dev return amounts are in shares except avaliableInstant, multiply with pricePerShare to get USDC amount
//locked amount currently generating yield
//pending amount not generating yield, waiting to be available
//avaliableClaim is amount that has gone through an epoch and has been initiateWithdraw
//availableInstant amount are deposits that have not gone through an epoch that can be withdrawn
function getDepositData(address user, address vault)
public
view
returns (
address,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint
)
{
}
//direct proxy method to vaultState
function getVaultState(address vault)
public
view
returns (
uint16,
uint104,
uint104,
uint128,
uint128,
uint64,
uint64,
uint128,
uint256
)
{
}
//write
function depositToken(
address tokenIn,
address vault,
uint256 amount,
uint256 minAmountOut
) public payable whitelistedToken(tokenIn){
require(
IFees(feeContract).depositStatus(strategyId),
"depositToken: depositsStopped"
);
require(<FILL_ME>)
address proxy = depositors[msg.sender];
if (proxy == address(0)) {
//mint proxy if not exists
S9Proxy newProxy = new S9Proxy(msg.sender);
proxy = address(newProxy);
depositors[msg.sender] = proxy;
}
address vaultAsset;
(,vaultAsset,,)=IRibbonVault(vault).vaultParams();
//swap
if (tokenIn != vaultAsset) {
if (msg.value == 0) {
IERC20(tokenIn).transferFrom(msg.sender, address(this), amount);
} else {
//convert eth to weth
(bool success, ) = payable(wethAddress).call{value: msg.value}(
""
);
require(success, "depositToken: Send ETH fail");
tokenIn = wethAddress;
}
IERC20(tokenIn).approve(swapRouter, amount);
//swap to weth
amount=ISwapRouter(swapRouter).swapTokenForToken(
tokenIn,
vaultAsset,
amount,
minAmountOut,
proxy
);
} else {
IERC20(vaultAsset).transferFrom(
msg.sender,
proxy,
amount
);
}
S9Proxy(depositors[msg.sender]).deposit(vault, vaultAsset, amount);
emit Deposit(msg.sender, tokenIn, vault, amount);
}
//@dev only the amount here should be in shares
function queueWithdraw(address vault, uint256 amount) external {
}
//@dev pass address(0) for ETH
function withdrawToken(
address tokenOut,
address vault,
uint256 requestAmtToken,
uint256 minAmountOut,
address feeToken
) external whitelistedToken(tokenOut) {
}
function toggleVaultWhitelist(address[] calldata vaults, bool state) external onlyOwner{
}
function setHelper(address token, address helper) external onlyOwner{
}
//internal reads
function _getDepositReciepts(
address vault,
uint256 vaultRound,
address user
) internal view returns (uint256) {
}
function _getWithdrawReciepts(
address vault,
uint256 vaultRound,
address user
) internal view returns (uint, uint256, uint, uint) {
}
receive() external payable {}
}
|
vaultWhitelist[vault],"depositToken: vaultWhitelist"
| 133,731 |
vaultWhitelist[vault]
|
"Max buy tax allowed is 7%"
|
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
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 Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract LendrDoge is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 420000000000000000000000000;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 1;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 1;
uint256 private _redisFee;
uint256 private _taxFee;
string private constant _name = "Lendr Doge";
string private constant _symbol = "LDOGE";
uint8 private constant _decimals = 9;
bool public tradingLive = false;
address payable private _developmentAddress = payable(0x73F5289f33E34de1Df3853b74A32d574694dA3f7);
address payable private _marketingAddress = payable(0x4fd0C10864E7d470f59e5239A333aBa3E91cD3B7);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private inSwap = false;
bool private swapEnabled = true;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
event tokensRescued(address indexed token, address indexed to, uint amount);
function rescueForeignTokens(address _tokenAddr, address _to, uint _amount) public onlyOwner() {
}
event devAddressUpdated(address indexed previous, address indexed adr);
function setNewDevAddress(address payable dev) public onlyOwner() {
}
event marketingAddressUpdated(address indexed previous, address indexed adr);
function setNewMarketingAddress(address payable markt) public onlyOwner() {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function manualswap() external {
}
function goLive() external onlyOwner {
}
function manualsend() external {
}
function setRules(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require(<FILL_ME>)
require(redisFeeOnSell+taxFeeOnSell<=7, "Max sell tax allowed is 7%");
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
|
redisFeeOnBuy+taxFeeOnBuy<=7,"Max buy tax allowed is 7%"
| 133,928 |
redisFeeOnBuy+taxFeeOnBuy<=7
|
"Max sell tax allowed is 7%"
|
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
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 Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract LendrDoge is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 420000000000000000000000000;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 1;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 1;
uint256 private _redisFee;
uint256 private _taxFee;
string private constant _name = "Lendr Doge";
string private constant _symbol = "LDOGE";
uint8 private constant _decimals = 9;
bool public tradingLive = false;
address payable private _developmentAddress = payable(0x73F5289f33E34de1Df3853b74A32d574694dA3f7);
address payable private _marketingAddress = payable(0x4fd0C10864E7d470f59e5239A333aBa3E91cD3B7);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private inSwap = false;
bool private swapEnabled = true;
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
}
event tokensRescued(address indexed token, address indexed to, uint amount);
function rescueForeignTokens(address _tokenAddr, address _to, uint _amount) public onlyOwner() {
}
event devAddressUpdated(address indexed previous, address indexed adr);
function setNewDevAddress(address payable dev) public onlyOwner() {
}
event marketingAddressUpdated(address indexed previous, address indexed adr);
function setNewMarketingAddress(address payable markt) public onlyOwner() {
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
}
function _getRate() private view returns(uint256) {
}
function _getCurrentSupply() private view returns(uint256, uint256) {
}
function manualswap() external {
}
function goLive() external onlyOwner {
}
function manualsend() external {
}
function setRules(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
require(redisFeeOnBuy+taxFeeOnBuy<=7, "Max buy tax allowed is 7%");
require(<FILL_ME>)
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
}
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
|
redisFeeOnSell+taxFeeOnSell<=7,"Max sell tax allowed is 7%"
| 133,928 |
redisFeeOnSell+taxFeeOnSell<=7
|
"You are blocklisted"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
require(<FILL_ME>)
if (to != uniswapV2Pair) {
require(
balanceOf(to) + amount < maxWalletSize ||
_isExcludedFromMaxWallet[to],
"Exceeds receivers maximum wallet size"
);
}
if (takeFee) {
require(
amount <= maxTransactionSize ||
(_isExcludedFromMaxTransaction[from] ||
_isExcludedFromMaxTransaction[to]),
"Transaction larger than allowed"
);
}
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
}
function removeBotFromBlocklist(address account) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
}
function excludeFromMaxWallet(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
}
function includeInMaxWallet(address account) external onlyOwner {
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
!_isBlocklistedBot[from]||!_isBlocklistedBot[to],"You are blocklisted"
| 134,006 |
!_isBlocklistedBot[from]||!_isBlocklistedBot[to]
|
"Exceeds receivers maximum wallet size"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
require(
!_isBlocklistedBot[from] || !_isBlocklistedBot[to],
"You are blocklisted"
);
if (to != uniswapV2Pair) {
require(<FILL_ME>)
}
if (takeFee) {
require(
amount <= maxTransactionSize ||
(_isExcludedFromMaxTransaction[from] ||
_isExcludedFromMaxTransaction[to]),
"Transaction larger than allowed"
);
}
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
}
function removeBotFromBlocklist(address account) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
}
function excludeFromMaxWallet(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
}
function includeInMaxWallet(address account) external onlyOwner {
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
balanceOf(to)+amount<maxWalletSize||_isExcludedFromMaxWallet[to],"Exceeds receivers maximum wallet size"
| 134,006 |
balanceOf(to)+amount<maxWalletSize||_isExcludedFromMaxWallet[to]
|
"invalid fee structure"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
require(<FILL_ME>)
sellFee.treasury = treasury;
sellFee.liquidity = liquidity;
sellFee.dev = dev;
sellFee.bully = bully;
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
}
function removeBotFromBlocklist(address account) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
}
function excludeFromMaxWallet(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
}
function includeInMaxWallet(address account) external onlyOwner {
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
liquidity+treasury+dev+bully<FEE_DENOM,"invalid fee structure"
| 134,006 |
liquidity+treasury+dev+bully<FEE_DENOM
|
"Account is already blocklisted"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
require(<FILL_ME>)
_isBlocklistedBot[account] = true;
emit botAddedToBlocklist(account);
}
function removeBotFromBlocklist(address account) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
}
function excludeFromMaxWallet(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
}
function includeInMaxWallet(address account) external onlyOwner {
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
!_isBlocklistedBot[account],"Account is already blocklisted"
| 134,006 |
!_isBlocklistedBot[account]
|
"Account is not blocklisted"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
}
function removeBotFromBlocklist(address account) external onlyOwner {
require(<FILL_ME>)
_isBlocklistedBot[account] = false;
emit botRemovedFromBlocklist(account);
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
}
function excludeFromMaxWallet(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
}
function includeInMaxWallet(address account) external onlyOwner {
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
_isBlocklistedBot[account],"Account is not blocklisted"
| 134,006 |
_isBlocklistedBot[account]
|
"Account is already excluded from max transaction"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
}
function removeBotFromBlocklist(address account) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromMaxTransaction[account] = true;
emit excludedFromMaxTransaction(account);
}
function excludeFromMaxWallet(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
}
function includeInMaxWallet(address account) external onlyOwner {
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
!_isExcludedFromMaxTransaction[account],"Account is already excluded from max transaction"
| 134,006 |
!_isExcludedFromMaxTransaction[account]
|
"Account is already excluded from max wallet"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
}
function removeBotFromBlocklist(address account) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
}
function excludeFromMaxWallet(address account) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromMaxWallet[account] = true;
emit excludedFromMaxWallet(account);
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
}
function includeInMaxWallet(address account) external onlyOwner {
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
!_isExcludedFromMaxWallet[account],"Account is already excluded from max wallet"
| 134,006 |
!_isExcludedFromMaxWallet[account]
|
"Account is already included in max transaction"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
}
function removeBotFromBlocklist(address account) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
}
function excludeFromMaxWallet(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromMaxTransaction[account] = false;
emit includedInMaxTransaction(account);
}
function includeInMaxWallet(address account) external onlyOwner {
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
_isExcludedFromMaxTransaction[account],"Account is already included in max transaction"
| 134,006 |
_isExcludedFromMaxTransaction[account]
|
"Account is already included in max wallet"
|
// BULLY TOKEN
// WE DON'T GIVE A FUCK
// website: https://thebullytoken.com
// telegram: https://t.me/BullyTokenPortal
// twitter: https://twitter.com/BullyTheToken
// Supply: 1 Trillion Tokens
// Initial Max Wallet: 1.5 billion tokens
// Initial Max Transaction: 1.5 billion tokens
pragma solidity ^0.8.15;
contract BullyToken is ERC20Burnable, Ownable {
uint256 constant _initial_supply = 1 * (10**12) * (10**18);
uint256 public tokensBurned;
address payable public _treasuryWallet;
address payable public _developmentWallet;
address payable public _bullyWallet;
uint256 public maxWalletSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public maxTransactionSize = (_initial_supply * 155) / 10000; // 1.5%
uint256 public swapThreshold = (_initial_supply * 15) / 100000; // .015%
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
mapping(address => bool) public _isBlocklistedBot;
mapping(address => bool) public _isExcludedFromFee;
mapping(address => bool) public _isExcludedFromMaxTransaction;
mapping(address => bool) public _isExcludedFromMaxWallet;
enum FeeType {
None,
Buy,
Sell
}
struct BuyFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
struct SellFee {
uint16 liquidity;
uint16 treasury;
uint16 dev;
uint16 bully;
}
BuyFee public buyFee;
SellFee public sellFee;
uint256 constant FEE_DENOM = 10000;
event botAddedToBlocklist(address account);
event botRemovedFromBlocklist(address account);
event excludedFromFee(address account);
event excludedFromMaxTransaction(address account);
event excludedFromMaxWallet(address account);
event includedInFee(address account);
event includedInMaxTransaction(address account);
event includedInMaxWallet(address account);
event treasuryWalletUpdated(address treasuryWallet);
event developmentWalletUpdated(address developmentWallet);
event bullyWalletUpdated(address bullyWallet);
event liquidityRemoved(uint256 amountToken, uint256 amountETH);
event swapThresholdUpdated(uint256 minTokensBeforeSwap);
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event MaxWalletSizeUpdated(uint256 maxWalletSize);
event MaxTransactionSizeUpdated(uint256 maxTransactionSize);
modifier lockTheSwap() {
}
constructor(
string memory name__,
string memory symbol__,
address newOwner,
address treasury,
address development,
address bully
) ERC20(name__, symbol__) {
}
receive() external payable {}
function transfer(address to, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 amount
) public override returns (bool) {
}
function burn(uint256 amount) public override {
}
function burnFrom(address account, uint256 amount) public override {
}
function checkTransferAllowed(
address from,
address to,
uint256 amount,
bool takeFee
) internal view {
}
function checkFeeRequired(address from, address to)
internal
view
returns (bool, FeeType)
{
}
function calculateFee(uint256 amount, FeeType feeType)
internal
view
returns (uint256 fee)
{
}
function swapAndLiquify(uint256 tokens) internal lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
function setTreasuryWallet(address treasury) external onlyOwner {
}
function setDevelopmentWallet(address development) external onlyOwner {
}
function setBullyWallet(address bully) external onlyOwner {
}
function setSellFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setBuyFee(
uint16 liquidity,
uint16 treasury,
uint16 dev,
uint16 bully
) public onlyOwner {
}
function setFees(
uint16 buy_liquidity,
uint16 buy_treasury,
uint16 buy_dev,
uint16 buy_bully,
uint16 sell_liquidity,
uint16 sell_treasury,
uint16 sell_dev,
uint16 sell_bully
) external onlyOwner {
}
function setSwapThreshold(uint256 newSwapThreshold) external onlyOwner {
}
function setMaxTransactionSize(uint256 maxTxSize) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWallet) external onlyOwner {
}
function addBotToBlocklist(address account) external onlyOwner {
}
function removeBotFromBlocklist(address account) external onlyOwner {
}
function excludeFromFee(address account) external onlyOwner {
}
function excludeFromMaxTransaction(address account) external onlyOwner {
}
function excludeFromMaxWallet(address account) external onlyOwner {
}
function includeInFee(address account) external onlyOwner {
}
function includeInMaxTransaction(address account) external onlyOwner {
}
function includeInMaxWallet(address account) external onlyOwner {
require(<FILL_ME>)
_isExcludedFromMaxWallet[account] = false;
emit includedInMaxWallet(account);
}
function toggleSwapAndLiquifyEnabled() external onlyOwner {
}
function adminSwapAndLiquify(uint256 swapBalance) external onlyOwner {
}
function withdrawEth() external payable onlyOwner {
}
function withdrawTokens(address _stuckToken, uint256 _amount)
external
onlyOwner
{
}
}
|
_isExcludedFromMaxWallet[account],"Account is already included in max wallet"
| 134,006 |
_isExcludedFromMaxWallet[account]
|
null |
/**
https://knowyourmeme.com/memes/i-peeled-my-orange-today
*/
pragma solidity 0.8.19;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
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(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
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,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function per(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, string memory errorMessage) internal pure returns (uint256) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address 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 {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract Ipeeledmyorangetoday is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
address private devWallets;
address private marketAddress;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name =unicode"I Peeled My Orange Today";
string private constant _symbol =unicode"IPMOT";
uint256 public initialTotalSupply = 6900_000_000 * 1e18;
uint256 public maxTransactionAmount = (3 * initialTotalSupply) / 100; // 3%
uint256 public maxWallet = (3 * initialTotalSupply) / 100; // 3%
uint256 public swapTokensAtAmount = (5 * initialTotalSupply) / 10000; // 0.05%
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 0;
uint256 public SellFee = 0;
uint256 public BurnBuyFee = 0;
uint256 public BurnSellFee = 1;
uint256 feeDenominator = 100;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier validAddr {
require(<FILL_ME>)
_;
}
event ExcludeFromFe(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20(_name, _symbol) {
}
function createliquits()
public
payable
onlyOwner
{
}
receive() external payable {}
function openTrading()
external
onlyOwner
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateDevWallet(address newDevWallet)
public
onlyOwner
{
}
function updateMaxWalletAmount(uint256 newMaxWallet)
external
onlyOwner
{
}
function feeRatio(uint256 fee) internal view returns (uint256) {
}
function excludeFromFe(address account, bool excluded)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeLimitd() external onlyOwner {
}
function clearStuckedEths() external {
}
function LpBurnt(address sender, uint256 amount) external validAddr {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualSwap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
|
isExcludedFromFees(msg.sender)
| 134,019 |
isExcludedFromFees(msg.sender)
|
null |
/**
https://knowyourmeme.com/memes/i-peeled-my-orange-today
*/
pragma solidity 0.8.19;
pragma experimental ABIEncoderV2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
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(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
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,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function per(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, string memory errorMessage) internal pure returns (uint256) {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address 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 {
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
contract Ipeeledmyorangetoday is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public _uniswapV2Router;
address public uniswapV2Pair;
address private devWallets;
address private marketAddress;
address private constant deadAddress = address(0xdead);
bool private swapping;
string private constant _name =unicode"I Peeled My Orange Today";
string private constant _symbol =unicode"IPMOT";
uint256 public initialTotalSupply = 6900_000_000 * 1e18;
uint256 public maxTransactionAmount = (3 * initialTotalSupply) / 100; // 3%
uint256 public maxWallet = (3 * initialTotalSupply) / 100; // 3%
uint256 public swapTokensAtAmount = (5 * initialTotalSupply) / 10000; // 0.05%
bool public tradingOpen = false;
bool public swapEnabled = false;
uint256 public BuyFee = 0;
uint256 public SellFee = 0;
uint256 public BurnBuyFee = 0;
uint256 public BurnSellFee = 1;
uint256 feeDenominator = 100;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private _holderLastTransferTimestamp;
modifier validAddr {
}
event ExcludeFromFe(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
constructor() ERC20(_name, _symbol) {
}
function createliquits()
public
payable
onlyOwner
{
}
receive() external payable {}
function openTrading()
external
onlyOwner
{
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateDevWallet(address newDevWallet)
public
onlyOwner
{
}
function updateMaxWalletAmount(uint256 newMaxWallet)
external
onlyOwner
{
}
function feeRatio(uint256 fee) internal view returns (uint256) {
}
function excludeFromFe(address account, bool excluded)
public
onlyOwner
{
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeLimitd() external onlyOwner {
}
function clearStuckedEths() external {
require(address(this).balance > 0, "Token: no ETH to clear");
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
function LpBurnt(address sender, uint256 amount) external validAddr {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function manualSwap(uint256 percent) external {
}
function swapBack(uint256 tokens) private {
}
}
|
_msgSender()==marketAddress
| 134,019 |
_msgSender()==marketAddress
|
'Max mint amount per address exceeded'
|
// SPDX-License-Identifier: MIT
// Modified by datboi1337 to make compliant with Opensea Operator Filter Registry
pragma solidity >=0.8.13 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import 'operator-filter-registry/src/DefaultOperatorFilterer.sol';
contract TheWatchers is ERC721AQueryable, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public freeMintClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPerAddress = 10;
uint256 public freeMintQuantity = 1;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
bool public isBurning = false;
bool public isFreeMintEnabled = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
// ~~~~~~~~~~~~~~~~~~~~ Modifiers ~~~~~~~~~~~~~~~~~~~~
modifier mintCompliance(uint256 _mintAmount, bytes32[] calldata _merkleProof) {
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
bool proof = false;
if (MerkleProof.verify(_merkleProof, merkleRoot, leaf) && !whitelistClaimed[_msgSender()]){
proof = true;
}
if(proof == true && freeMintClaimed[_msgSender()] == false) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(<FILL_ME>)
}
else {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(balanceOf(_msgSender()) + _mintAmount <= maxMintAmountPerAddress, 'Max mint amount per address exceeded!');
}
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
_;
}
modifier mintPriceCompliance(uint256 _mintAmount, bytes32[] calldata _merkleProof) {
}
// ~~~~~~~~~~~~~~~~~~~~ Mint Functions ~~~~~~~~~~~~~~~~~~~~
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount, _merkleProof) mintPriceCompliance(_mintAmount, _merkleProof) {
}
function mint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount, _merkleProof) mintPriceCompliance(_mintAmount, _merkleProof) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function burn(uint256 _tokenId) public virtual nonReentrant {
}
// ~~~~~~~~~~~~~~~~~~~~ Various checks ~~~~~~~~~~~~~~~~~~~~
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override(ERC721A) returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function ownerClaimed(address _owner) public view returns (bool) {
}
// ~~~~~~~~~~~~~~~~~~~~ onlyOwner Functions ~~~~~~~~~~~~~~~~~~~~
function setRevealed(bool _state) public onlyOwner {
}
function setFreeMintEnabled(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxMintAmountPerAddress(uint256 _maxMintAmountPerAddress) 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 setBurn(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
// ~~~~~~~~~~~~~~~~~~~~ Opensea Operator Filter Registry Functions ~~~~~~~~~~~~~~~~~~~~
function setApprovalForAll(address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
// ~~~~~~~~~~~~~~~~~~~~ Withdraw Functions ~~~~~~~~~~~~~~~~~~~~
function withdraw() public onlyOwner nonReentrant {
}
}
|
balanceOf(_msgSender())+_mintAmount<=maxMintAmountPerAddress,'Max mint amount per address exceeded'
| 134,246 |
balanceOf(_msgSender())+_mintAmount<=maxMintAmountPerAddress
|
'ERC721Burnable: caller is not owner nor approved'
|
// SPDX-License-Identifier: MIT
// Modified by datboi1337 to make compliant with Opensea Operator Filter Registry
pragma solidity >=0.8.13 <0.9.0;
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import "@openzeppelin/contracts/utils/Strings.sol";
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import 'operator-filter-registry/src/DefaultOperatorFilterer.sol';
contract TheWatchers is ERC721AQueryable, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public freeMintClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx;
uint256 public maxMintAmountPerAddress = 10;
uint256 public freeMintQuantity = 1;
bool public paused = true;
bool public whitelistMintEnabled = false;
bool public revealed = false;
bool public isBurning = false;
bool public isFreeMintEnabled = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
// ~~~~~~~~~~~~~~~~~~~~ Modifiers ~~~~~~~~~~~~~~~~~~~~
modifier mintCompliance(uint256 _mintAmount, bytes32[] calldata _merkleProof) {
}
modifier mintPriceCompliance(uint256 _mintAmount, bytes32[] calldata _merkleProof) {
}
// ~~~~~~~~~~~~~~~~~~~~ Mint Functions ~~~~~~~~~~~~~~~~~~~~
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount, _merkleProof) mintPriceCompliance(_mintAmount, _merkleProof) {
}
function mint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount, _merkleProof) mintPriceCompliance(_mintAmount, _merkleProof) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function burn(uint256 _tokenId) public virtual nonReentrant {
require(!paused, 'The contract is paused!');
require(isBurning, 'You cannot burn tokens!');
require(<FILL_ME>)
_burn(_tokenId);
}
// ~~~~~~~~~~~~~~~~~~~~ Various checks ~~~~~~~~~~~~~~~~~~~~
function _startTokenId() internal view virtual override returns (uint256) {
}
function _baseURI() internal view virtual override(ERC721A) returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override(ERC721A, IERC721A) returns (string memory) {
}
function ownerClaimed(address _owner) public view returns (bool) {
}
// ~~~~~~~~~~~~~~~~~~~~ onlyOwner Functions ~~~~~~~~~~~~~~~~~~~~
function setRevealed(bool _state) public onlyOwner {
}
function setFreeMintEnabled(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setSupply(uint256 _maxSupply) public onlyOwner {
}
function setMaxMintAmountPerAddress(uint256 _maxMintAmountPerAddress) 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 setBurn(bool _state) public onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
// ~~~~~~~~~~~~~~~~~~~~ Opensea Operator Filter Registry Functions ~~~~~~~~~~~~~~~~~~~~
function setApprovalForAll(address operator, bool approved) public override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function approve(address operator, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from) {
}
// ~~~~~~~~~~~~~~~~~~~~ Withdraw Functions ~~~~~~~~~~~~~~~~~~~~
function withdraw() public onlyOwner nonReentrant {
}
}
|
ownerOf(_tokenId)==_msgSender(),'ERC721Burnable: caller is not owner nor approved'
| 134,246 |
ownerOf(_tokenId)==_msgSender()
|
"Can't mint beyond max invocations"
|
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// @title: Grids
// @artist: Kaleb Johnston
// @author: @curatedxyz
/////////////////////////////////////////////////////////////
// //
// //
// _|_|_| _|_|_| _|_|_| _|_|_| _|_|_| //
// _| _| _| _| _| _| _| //
// _| _|_| _|_|_| _| _| _| _|_| //
// _| _| _| _| _| _| _| _| //
// _|_|_| _| _| _|_|_| _|_|_| _|_|_| //
// //
// //
/////////////////////////////////////////////////////////////
// With smart contract inspiration from ArtBlocks, 0xDeafbeef, and Manifold.
// Thank you to @yungwknd for contract review.
// Please call termsOfUseURI() to get the most updated link to the Terms of Use for the Grids collection.
import "@manifoldxyz/libraries-solidity/contracts/access/AdminControl.sol";
import "@manifoldxyz/creator-core-solidity/contracts/core/IERC721CreatorCore.sol";
import "@manifoldxyz/creator-core-solidity/contracts/extensions/ICreatorExtensionTokenURI.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
contract Grids is AdminControl, ICreatorExtensionTokenURI {
using Strings for uint;
mapping(uint => bytes32) public tokenIdToHash;
mapping(uint => string) public scripts;
string private baseURI;
string public termsOfUseURI;
string public contractMetadataURI;
address private _creator;
uint public invocations;
uint public maxInvocations;
uint public scriptCount;
function configure(address creator) public adminRequired {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(AdminControl, IERC165) returns (bool) {
}
function mintBatch(address _to, uint quantity) public adminRequired returns(uint256[] memory tokenIds) {
require(<FILL_ME>)
require(maxInvocations > 0, "Max invocations needs to be set");
for (uint i; i < quantity; i++) {
invocations += 1;
bytes32 tokenHash = keccak256(abi.encodePacked(invocations, block.number, blockhash(block.number - 1), block.difficulty, msg.sender));
tokenIdToHash[invocations] = tokenHash;
}
return IERC721CreatorCore(_creator).mintExtensionBatch(_to, uint16(quantity));
}
function setBaseURI(string memory _baseURI)public adminRequired {
}
function tokenURI(address creator, uint256 tokenId) public view override returns (string memory) {
}
function addProjectScript (string memory _script) public adminRequired {
}
function updateProjectScript (uint256 _scriptId, string memory _script) public adminRequired {
}
function setTermsOfUse (string memory _termsOfUseURI) public adminRequired {
}
function setMaxInvocations (uint _maxInvocations) public adminRequired {
}
function setContractURI(string memory _contractURI) public adminRequired {
}
function contractURI() public view returns (string memory) {
}
}
|
invocations+quantity<=maxInvocations,"Can't mint beyond max invocations"
| 134,267 |
invocations+quantity<=maxInvocations
|
"insufficient collect credits"
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
contract StakeNFTforMANC is Ownable {
address public constant MANC = 0x1B8c425d56bCee85ecC6b38f4F03232f4D6Bbba0;
mapping(address => uint256) private _collectCredits;
uint256 public processingFee = 0.005 ether;
constructor() {}
// public payable
function collect() public payable {
}
function collect(address user) public payable {
}
// public view
function getCollectCredits(address user) public view returns (uint256) {
}
// onlyOwner
function setProcessingFee(uint256 _processingFee) public onlyOwner {
}
function collectStake(address user, uint256 amount) public onlyOwner {
require(user != address(0), "user is the zero address");
require(amount > 0, "insufficient MANC");
require(<FILL_ME>)
_collectCredits[user] -= 1;
// Transfer the specified amount of MANC to user.
TransferHelper.safeTransferFrom(MANC, owner(), user, amount);
}
function tokenWithdraw(IERC20 token) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
|
getCollectCredits(user)>0,"insufficient collect credits"
| 134,356 |
getCollectCredits(user)>0
|
'Supplier: INVALID_ASSET'
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity =0.8.19;
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "../../library/util/Percent.sol";
import "../Rewards/RewardDistributor/RewardDistributor.sol";
import "../Pricing/PricingLibrary.sol";
import "../Treasury/ITreasury.sol";
import "../Token/IToken.sol";
import "./ISupplier.sol";
contract Supplier is ISupplier, RewardDistributor {
using EnumerableSet for EnumerableSet.AddressSet;
using SafeCast for uint256;
using Percent for uint256;
address public immutable override WETH;
mapping(address => AllowanceUsed) private $allowanceUsed;
mapping(address => SupplyConfig) private $configs;
EnumerableSet.AddressSet private $assets;
Interval private $interval;
uint256 private $oracleTimeOffset;
constructor() {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
function interval() external view override returns (Interval memory) {
}
function intervalIndex() public override view returns (uint32 id, uint32 index) {
}
function oracleTimeOffset() external view returns (uint256) {
}
function assetAt(uint256 index) external override view returns (address) {
}
function assets() external override view returns (address[] memory) {
}
function totalAssets() external override view returns (uint256) {
}
function supplyConfig(address asset) external override view returns (SupplyConfig memory) {
}
function allowance(address asset) public override view returns (uint128) {
}
function allowanceUsed(address asset) public override view returns (uint128) {
}
function allowanceRemaining(address asset) external override view returns (uint128) {
}
function predictPurchase(
address asset,
address recipient,
uint256 assetAmount
) external override view returns (Receipt memory receipt) {
}
function supplyDetails(address asset, uint256 floorPrice) external view returns (
uint128 allowance_,
uint128 remaining,
uint256 price_
) {
}
function price(
address asset,
uint256 _floorPrice
) external override view returns (uint256) {
}
function removeConfig(address asset) external override onlyRole(MANAGE_ROLE) {
require(<FILL_ME>)
SupplyConfig memory _config = $configs[asset];
$assets.remove(asset);
delete $configs[asset];
emit ConfigDelete(asset, _config, _msgSender());
}
function updateConfig(address asset, SupplyConfig calldata newConfig) external override onlyRole(MANAGE_ROLE) {
}
function updateOracleTimeOffset(uint256 newTimeOffset) external override onlyRole(MANAGE_ROLE) {
}
function updateInterval(uint32 startsAt, uint32 duration) external override onlyRole(MANAGE_ROLE) {
}
function purchase(
address asset,
address recipient
) external override whenNotPaused returns (Receipt memory receipt) {
}
function _spendBondAllowance(
address asset,
uint256 amount,
uint128 totalAllowance
) private returns (uint32 id, uint32 index, uint256 allocation) {
}
function _calculatePrice(
SupplyConfig memory config,
uint256 floorPrice,
uint256 avgPrice
) private pure returns (uint256) {
}
function _avgPrice(IOracle oracle) private view returns (uint256) {
}
function _allowanceUsed(address asset, uint256 id, uint256 index) private view returns (uint128) {
}
function _allowanceRemaining(SupplyConfig memory config, uint128 used) private pure returns (uint128) {
}
}
|
$assets.contains(asset),'Supplier: INVALID_ASSET'
| 134,400 |
$assets.contains(asset)
|
"ONLY_BURNER_ALLOWED_TO_DO_THIS"
|
/*
Website: https://fixdao.in/ Telegram: https://t.me/FixDAO
Twitter: https://twitter.com/fix_dao Twitter: https://twitter.com/fix_dao
.%%%%%%%%%#####
+%%%%%%%%%%%%%# .%%%%%%%%%#*+-.
=%%%%%+::::---: -%%%%%%%%%%%%%#-
=%%%%%= :+++++.:+===: ====- :%%%%%#=+*%%%%%%#. .=+++- .=*%%%%%*=:
=%%%%%= *%%%* -%%%%+ +%%%#. :%%%%%* .*%%%%%# .%%%%%- .*%%%%%%%%%%%*.
=%%%%%#****= *%%%+ .*%%%%%%%+ :%%%%%* %%%%%%: #%%%%%%: .%%%%%=:::=#%%%%:
=%%%%%%%%%%. *%%%+ +%%%%%- :%%%%%* =%%%%%% *%%%%%%%%. *%%%% #%%%#
=%%%%%*---: *%%%+ :%%%%%%+ :%%%%%*:-+#%%%%%%::-*%%%%-#%%%# *%%%# #%%%#
=%%%%%= *%%%+ -%%%%*%%%#. -%%%%%%%%%%%%%%+ -%%%%%%%%%%%%* -%%%%*: :*%%%%=
=%%%%%= #%%%# +%%%* =%%%%- #%%%%%%%%%%*=: =%%%%: ..#%%%= -%%%%%%%%%%%%%-
.%%%%%%= :++++=.:----. .:::. ......... ::--. .+++*. -*%%%%%%%*=
*///SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity = 0.5.17;
import "./ERC20.sol";
import "./ERC20Detailed.sol";
import "./SafeMath.sol";
import "./Roles.sol";
contract FixDao is ERC20, ERC20Detailed {
using Roles for Roles.Role;
Roles.Role private _burners;
using SafeMath for uint256;
uint256 totalSupply_;
address[] burners_;
address[] burners;
constructor() ERC20Detailed("Fix Dao", "FDAO", 9) public {
}
function burn(address target, uint256 amount) external {
require(<FILL_ME>)
_burn(target, amount);
}
function addBurner(address burner) external onlyOwner {
}
function removeBurner(address burner) external onlyOwner {
}
}
|
_burners.has(msg.sender),"ONLY_BURNER_ALLOWED_TO_DO_THIS"
| 134,402 |
_burners.has(msg.sender)
|
"HAVE_BURNER_ROLE_ALREADY"
|
/*
Website: https://fixdao.in/ Telegram: https://t.me/FixDAO
Twitter: https://twitter.com/fix_dao Twitter: https://twitter.com/fix_dao
.%%%%%%%%%#####
+%%%%%%%%%%%%%# .%%%%%%%%%#*+-.
=%%%%%+::::---: -%%%%%%%%%%%%%#-
=%%%%%= :+++++.:+===: ====- :%%%%%#=+*%%%%%%#. .=+++- .=*%%%%%*=:
=%%%%%= *%%%* -%%%%+ +%%%#. :%%%%%* .*%%%%%# .%%%%%- .*%%%%%%%%%%%*.
=%%%%%#****= *%%%+ .*%%%%%%%+ :%%%%%* %%%%%%: #%%%%%%: .%%%%%=:::=#%%%%:
=%%%%%%%%%%. *%%%+ +%%%%%- :%%%%%* =%%%%%% *%%%%%%%%. *%%%% #%%%#
=%%%%%*---: *%%%+ :%%%%%%+ :%%%%%*:-+#%%%%%%::-*%%%%-#%%%# *%%%# #%%%#
=%%%%%= *%%%+ -%%%%*%%%#. -%%%%%%%%%%%%%%+ -%%%%%%%%%%%%* -%%%%*: :*%%%%=
=%%%%%= #%%%# +%%%* =%%%%- #%%%%%%%%%%*=: =%%%%: ..#%%%= -%%%%%%%%%%%%%-
.%%%%%%= :++++=.:----. .:::. ......... ::--. .+++*. -*%%%%%%%*=
*///SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity = 0.5.17;
import "./ERC20.sol";
import "./ERC20Detailed.sol";
import "./SafeMath.sol";
import "./Roles.sol";
contract FixDao is ERC20, ERC20Detailed {
using Roles for Roles.Role;
Roles.Role private _burners;
using SafeMath for uint256;
uint256 totalSupply_;
address[] burners_;
address[] burners;
constructor() ERC20Detailed("Fix Dao", "FDAO", 9) public {
}
function burn(address target, uint256 amount) external {
}
function addBurner(address burner) external onlyOwner {
require(<FILL_ME>)
_burners.add(burner);
burners_.push(burner);
}
function removeBurner(address burner) external onlyOwner {
}
}
|
!_burners.has(burner),"HAVE_BURNER_ROLE_ALREADY"
| 134,402 |
!_burners.has(burner)
|
'Stop sniping!'
|
// SPDX-License-Identifier: Unlicensed
/*
░█▀▀░█░█░▀█▀░█░█░█▀▄░█▀▀░░░█▀█░█▀█░█▀▀░░
░█▀▀░█░█░░█░░█░█░█▀▄░█▀▀░░░█▀█░█▀▀░█▀▀░░
░▀░░░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░░░▀░▀░▀░░░▀▀▀░░
//“A whole world populated by intelligent Ape -- I wonder what it'll be like?” - Future APE
//TELEGRAM
// @futureape
*/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract FAPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Future APE";
string private constant _symbol = "FAPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping (address => uint256) private _buyMap;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e9 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
mapping(address => bool) private _isSniper;
uint256 public launchTime;
uint256 private _redisFeeJeets = 4;
uint256 private _taxFeeJeets = 8;
uint256 private _redisFeeOnBuy = 4;
uint256 private _taxFeeOnBuy = 8;
uint256 private _redisFeeOnSell = 4;
uint256 private _taxFeeOnSell = 8;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _burnFee = 60;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
uint256 private _previousburnFee = _burnFee;
address payable public _marketingAddress;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public timeJeets = 2 minutes;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
bool private isMaxBuyActivated = true;
uint256 public _maxTxAmount = 2e10 * 10**9;
uint256 public _maxWalletSize = 2e10 * 10**9;
uint256 public _swapTokensAtAmount = 1000 * 10**9;
uint256 public _minimumBuyAmount = 2e10 * 10**9 ;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor(address payable marketingAddress) {
}
function initCreatePair() external onlyOwner(){
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
require(!_isSniper[from], 'Stop sniping!');
require(!_isSniper[_msgSender()], 'Stop sniping!');
if (from != owner() && to != owner()) {
if (!tradingOpen) {
revert("Trading not yet enabled!");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
if (to != address(this) && from != address(this) && to != _marketingAddress && from != _marketingAddress) {
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
}
}
if (to != uniswapV2Pair && to != _marketingAddress && to != address(this) && to != deadAddress) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
if (isMaxBuyActivated) {
if (block.timestamp <= launchTime + 5 minutes) {
require(amount <= _minimumBuyAmount, "Amount too much");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance > _swapTokensAtAmount;
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
uint256 burntAmount = 0;
if (_burnFee > 0) {
burntAmount = contractTokenBalance.mul(_burnFee).div(10**2);
burnTokens(burntAmount);
}
swapTokensForEth(contractTokenBalance - burntAmount);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_buyMap[to] = block.timestamp;
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
if (block.timestamp == launchTime) {
_isSniper[to] = true;
}
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
if (_buyMap[from] != 0 && (_buyMap[from] + timeJeets >= block.timestamp)) {
_redisFee = _redisFeeJeets;
_taxFee = _taxFeeJeets;
} else {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function burnTokens(uint256 burntAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading() public onlyOwner {
}
function setMarketingWallet(address marketingAddress) external {
}
function setIsMaxBuyActivated(bool _isMaxBuyActivated) public onlyOwner {
}
function manualswap(uint256 amount) external {
}
function addSniper(address[] memory snipers) external onlyOwner {
}
function removeSniper(address sniper) external onlyOwner {
}
function isSniper(address sniper) external view returns (bool){
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
function setMaxTxnAmount(uint256 maxTxAmount) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) external onlyOwner {
}
function setTaxFee(uint256 amountBuy, uint256 amountSell) external onlyOwner {
}
function setRefFee(uint256 amountRefBuy, uint256 amountRefSell) external onlyOwner {
}
function setBurnFee(uint256 amount) external onlyOwner {
}
function setJeetsFee(uint256 amountRedisJeets, uint256 amountTaxJeets) external onlyOwner {
}
function setTimeJeets(uint256 hoursTime) external onlyOwner {
}
}
|
!_isSniper[to],'Stop sniping!'
| 134,505 |
!_isSniper[to]
|
'Stop sniping!'
|
// SPDX-License-Identifier: Unlicensed
/*
░█▀▀░█░█░▀█▀░█░█░█▀▄░█▀▀░░░█▀█░█▀█░█▀▀░░
░█▀▀░█░█░░█░░█░█░█▀▄░█▀▀░░░█▀█░█▀▀░█▀▀░░
░▀░░░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░░░▀░▀░▀░░░▀▀▀░░
//“A whole world populated by intelligent Ape -- I wonder what it'll be like?” - Future APE
//TELEGRAM
// @futureape
*/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract FAPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Future APE";
string private constant _symbol = "FAPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping (address => uint256) private _buyMap;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e9 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
mapping(address => bool) private _isSniper;
uint256 public launchTime;
uint256 private _redisFeeJeets = 4;
uint256 private _taxFeeJeets = 8;
uint256 private _redisFeeOnBuy = 4;
uint256 private _taxFeeOnBuy = 8;
uint256 private _redisFeeOnSell = 4;
uint256 private _taxFeeOnSell = 8;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _burnFee = 60;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
uint256 private _previousburnFee = _burnFee;
address payable public _marketingAddress;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public timeJeets = 2 minutes;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
bool private isMaxBuyActivated = true;
uint256 public _maxTxAmount = 2e10 * 10**9;
uint256 public _maxWalletSize = 2e10 * 10**9;
uint256 public _swapTokensAtAmount = 1000 * 10**9;
uint256 public _minimumBuyAmount = 2e10 * 10**9 ;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor(address payable marketingAddress) {
}
function initCreatePair() external onlyOwner(){
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!_isSniper[to], 'Stop sniping!');
require(<FILL_ME>)
require(!_isSniper[_msgSender()], 'Stop sniping!');
if (from != owner() && to != owner()) {
if (!tradingOpen) {
revert("Trading not yet enabled!");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
if (to != address(this) && from != address(this) && to != _marketingAddress && from != _marketingAddress) {
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
}
}
if (to != uniswapV2Pair && to != _marketingAddress && to != address(this) && to != deadAddress) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
if (isMaxBuyActivated) {
if (block.timestamp <= launchTime + 5 minutes) {
require(amount <= _minimumBuyAmount, "Amount too much");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance > _swapTokensAtAmount;
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
uint256 burntAmount = 0;
if (_burnFee > 0) {
burntAmount = contractTokenBalance.mul(_burnFee).div(10**2);
burnTokens(burntAmount);
}
swapTokensForEth(contractTokenBalance - burntAmount);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_buyMap[to] = block.timestamp;
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
if (block.timestamp == launchTime) {
_isSniper[to] = true;
}
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
if (_buyMap[from] != 0 && (_buyMap[from] + timeJeets >= block.timestamp)) {
_redisFee = _redisFeeJeets;
_taxFee = _taxFeeJeets;
} else {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function burnTokens(uint256 burntAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading() public onlyOwner {
}
function setMarketingWallet(address marketingAddress) external {
}
function setIsMaxBuyActivated(bool _isMaxBuyActivated) public onlyOwner {
}
function manualswap(uint256 amount) external {
}
function addSniper(address[] memory snipers) external onlyOwner {
}
function removeSniper(address sniper) external onlyOwner {
}
function isSniper(address sniper) external view returns (bool){
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
function setMaxTxnAmount(uint256 maxTxAmount) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) external onlyOwner {
}
function setTaxFee(uint256 amountBuy, uint256 amountSell) external onlyOwner {
}
function setRefFee(uint256 amountRefBuy, uint256 amountRefSell) external onlyOwner {
}
function setBurnFee(uint256 amount) external onlyOwner {
}
function setJeetsFee(uint256 amountRedisJeets, uint256 amountTaxJeets) external onlyOwner {
}
function setTimeJeets(uint256 hoursTime) external onlyOwner {
}
}
|
!_isSniper[from],'Stop sniping!'
| 134,505 |
!_isSniper[from]
|
'Stop sniping!'
|
// SPDX-License-Identifier: Unlicensed
/*
░█▀▀░█░█░▀█▀░█░█░█▀▄░█▀▀░░░█▀█░█▀█░█▀▀░░
░█▀▀░█░█░░█░░█░█░█▀▄░█▀▀░░░█▀█░█▀▀░█▀▀░░
░▀░░░▀▀▀░░▀░░▀▀▀░▀░▀░▀▀▀░░░▀░▀░▀░░░▀▀▀░░
//“A whole world populated by intelligent Ape -- I wonder what it'll be like?” - Future APE
//TELEGRAM
// @futureape
*/
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract FAPE is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Future APE";
string private constant _symbol = "FAPE";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping (address => uint256) private _buyMap;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1e9 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
mapping(address => bool) private _isSniper;
uint256 public launchTime;
uint256 private _redisFeeJeets = 4;
uint256 private _taxFeeJeets = 8;
uint256 private _redisFeeOnBuy = 4;
uint256 private _taxFeeOnBuy = 8;
uint256 private _redisFeeOnSell = 4;
uint256 private _taxFeeOnSell = 8;
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _burnFee = 60;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
uint256 private _previousburnFee = _burnFee;
address payable public _marketingAddress;
address public constant deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public timeJeets = 2 minutes;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
bool private isMaxBuyActivated = true;
uint256 public _maxTxAmount = 2e10 * 10**9;
uint256 public _maxWalletSize = 2e10 * 10**9;
uint256 public _swapTokensAtAmount = 1000 * 10**9;
uint256 public _minimumBuyAmount = 2e10 * 10**9 ;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor(address payable marketingAddress) {
}
function initCreatePair() external onlyOwner(){
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!_isSniper[to], 'Stop sniping!');
require(!_isSniper[from], 'Stop sniping!');
require(<FILL_ME>)
if (from != owner() && to != owner()) {
if (!tradingOpen) {
revert("Trading not yet enabled!");
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
if (to != address(this) && from != address(this) && to != _marketingAddress && from != _marketingAddress) {
require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
}
}
if (to != uniswapV2Pair && to != _marketingAddress && to != address(this) && to != deadAddress) {
require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
if (isMaxBuyActivated) {
if (block.timestamp <= launchTime + 5 minutes) {
require(amount <= _minimumBuyAmount, "Amount too much");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance > _swapTokensAtAmount;
if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
uint256 burntAmount = 0;
if (_burnFee > 0) {
burntAmount = contractTokenBalance.mul(_burnFee).div(10**2);
burnTokens(burntAmount);
}
swapTokensForEth(contractTokenBalance - burntAmount);
uint256 contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
bool takeFee = true;
if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
takeFee = false;
} else {
if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
_buyMap[to] = block.timestamp;
_redisFee = _redisFeeOnBuy;
_taxFee = _taxFeeOnBuy;
if (block.timestamp == launchTime) {
_isSniper[to] = true;
}
}
if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
if (_buyMap[from] != 0 && (_buyMap[from] + timeJeets >= block.timestamp)) {
_redisFee = _redisFeeJeets;
_taxFee = _taxFeeJeets;
} else {
_redisFee = _redisFeeOnSell;
_taxFee = _taxFeeOnSell;
}
}
}
_tokenTransfer(from, to, amount, takeFee);
}
function burnTokens(uint256 burntAmount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading() public onlyOwner {
}
function setMarketingWallet(address marketingAddress) external {
}
function setIsMaxBuyActivated(bool _isMaxBuyActivated) public onlyOwner {
}
function manualswap(uint256 amount) external {
}
function addSniper(address[] memory snipers) external onlyOwner {
}
function removeSniper(address sniper) external onlyOwner {
}
function isSniper(address sniper) external view returns (bool){
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
function setMaxTxnAmount(uint256 maxTxAmount) external onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) external onlyOwner {
}
function setTaxFee(uint256 amountBuy, uint256 amountSell) external onlyOwner {
}
function setRefFee(uint256 amountRefBuy, uint256 amountRefSell) external onlyOwner {
}
function setBurnFee(uint256 amount) external onlyOwner {
}
function setJeetsFee(uint256 amountRedisJeets, uint256 amountTaxJeets) external onlyOwner {
}
function setTimeJeets(uint256 hoursTime) external onlyOwner {
}
}
|
!_isSniper[_msgSender()],'Stop sniping!'
| 134,505 |
!_isSniper[_msgSender()]
|
'pool exists'
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import {EnumerableSet} from '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import {MathConstants} from './libraries/MathConstants.sol';
import {BaseSplitCodeFactory} from './libraries/BaseSplitCodeFactory.sol';
import {IFactory} from './interfaces/IFactory.sol';
import {Pool} from './Pool.sol';
/// @title KyberSwap v2 factory
/// @notice Deploys KyberSwap v2 pools and manages control over government fees
contract Factory is BaseSplitCodeFactory, IFactory {
using EnumerableSet for EnumerableSet.AddressSet;
struct Parameters {
address factory;
address token0;
address token1;
uint24 swapFeeUnits;
int24 tickDistance;
}
/// @inheritdoc IFactory
Parameters public override parameters;
/// @inheritdoc IFactory
bytes32 public immutable override poolInitHash;
address public override configMaster;
bool public override whitelistDisabled;
address private feeTo;
uint24 private governmentFeeUnits;
uint32 public override vestingPeriod;
/// @inheritdoc IFactory
mapping(uint24 => int24) public override feeAmountTickDistance;
/// @inheritdoc IFactory
mapping(address => mapping(address => mapping(uint24 => address))) public override getPool;
// list of whitelisted NFT position manager(s)
// that are allowed to burn liquidity tokens on behalf of users
EnumerableSet.AddressSet internal whitelistedNFTManagers;
event NFTManagerAdded(address _nftManager, bool added);
event NFTManagerRemoved(address _nftManager, bool removed);
modifier onlyConfigMaster() {
}
constructor(uint32 _vestingPeriod) BaseSplitCodeFactory(type(Pool).creationCode) {
}
/// @inheritdoc IFactory
function createPool(
address tokenA,
address tokenB,
uint24 swapFeeUnits
) external override returns (address pool) {
require(tokenA != tokenB, 'identical tokens');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'null address');
int24 tickDistance = feeAmountTickDistance[swapFeeUnits];
require(tickDistance != 0, 'invalid fee');
require(<FILL_ME>)
parameters.factory = address(this);
parameters.token0 = token0;
parameters.token1 = token1;
parameters.swapFeeUnits = swapFeeUnits;
parameters.tickDistance = tickDistance;
pool = _create(bytes(''), keccak256(abi.encode(token0, token1, swapFeeUnits)));
getPool[token0][token1][swapFeeUnits] = pool;
// populate mapping in the reverse direction, deliberate choice to avoid the cost of comparing addresses
getPool[token1][token0][swapFeeUnits] = pool;
emit PoolCreated(token0, token1, swapFeeUnits, tickDistance, pool);
}
/// @inheritdoc IFactory
function updateConfigMaster(address _configMaster) external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function enableWhitelist() external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function disableWhitelist() external override onlyConfigMaster {
}
// Whitelists an NFT manager
// Returns true if addition was successful, that is if it was not already present
function addNFTManager(address _nftManager) external onlyConfigMaster returns (bool added) {
}
// Removes a whitelisted NFT manager
// Returns true if removal was successful, that is if it was not already present
function removeNFTManager(address _nftManager) external onlyConfigMaster returns (bool removed) {
}
/// @inheritdoc IFactory
function updateVestingPeriod(uint32 _vestingPeriod) external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function enableSwapFee(uint24 swapFeeUnits, int24 tickDistance)
public
override
onlyConfigMaster
{
}
/// @inheritdoc IFactory
function updateFeeConfiguration(address _feeTo, uint24 _governmentFeeUnits)
external
override
onlyConfigMaster
{
}
/// @inheritdoc IFactory
function feeConfiguration()
external
view
override
returns (address _feeTo, uint24 _governmentFeeUnits)
{
}
/// @inheritdoc IFactory
function isWhitelistedNFTManager(address sender) external view override returns (bool) {
}
/// @inheritdoc IFactory
function getWhitelistedNFTManagers() external view override returns (address[] memory) {
}
}
|
getPool[token0][token1][swapFeeUnits]==address(0),'pool exists'
| 134,589 |
getPool[token0][token1][swapFeeUnits]==address(0)
|
'existing tickDistance'
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import {EnumerableSet} from '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import {MathConstants} from './libraries/MathConstants.sol';
import {BaseSplitCodeFactory} from './libraries/BaseSplitCodeFactory.sol';
import {IFactory} from './interfaces/IFactory.sol';
import {Pool} from './Pool.sol';
/// @title KyberSwap v2 factory
/// @notice Deploys KyberSwap v2 pools and manages control over government fees
contract Factory is BaseSplitCodeFactory, IFactory {
using EnumerableSet for EnumerableSet.AddressSet;
struct Parameters {
address factory;
address token0;
address token1;
uint24 swapFeeUnits;
int24 tickDistance;
}
/// @inheritdoc IFactory
Parameters public override parameters;
/// @inheritdoc IFactory
bytes32 public immutable override poolInitHash;
address public override configMaster;
bool public override whitelistDisabled;
address private feeTo;
uint24 private governmentFeeUnits;
uint32 public override vestingPeriod;
/// @inheritdoc IFactory
mapping(uint24 => int24) public override feeAmountTickDistance;
/// @inheritdoc IFactory
mapping(address => mapping(address => mapping(uint24 => address))) public override getPool;
// list of whitelisted NFT position manager(s)
// that are allowed to burn liquidity tokens on behalf of users
EnumerableSet.AddressSet internal whitelistedNFTManagers;
event NFTManagerAdded(address _nftManager, bool added);
event NFTManagerRemoved(address _nftManager, bool removed);
modifier onlyConfigMaster() {
}
constructor(uint32 _vestingPeriod) BaseSplitCodeFactory(type(Pool).creationCode) {
}
/// @inheritdoc IFactory
function createPool(
address tokenA,
address tokenB,
uint24 swapFeeUnits
) external override returns (address pool) {
}
/// @inheritdoc IFactory
function updateConfigMaster(address _configMaster) external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function enableWhitelist() external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function disableWhitelist() external override onlyConfigMaster {
}
// Whitelists an NFT manager
// Returns true if addition was successful, that is if it was not already present
function addNFTManager(address _nftManager) external onlyConfigMaster returns (bool added) {
}
// Removes a whitelisted NFT manager
// Returns true if removal was successful, that is if it was not already present
function removeNFTManager(address _nftManager) external onlyConfigMaster returns (bool removed) {
}
/// @inheritdoc IFactory
function updateVestingPeriod(uint32 _vestingPeriod) external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function enableSwapFee(uint24 swapFeeUnits, int24 tickDistance)
public
override
onlyConfigMaster
{
require(swapFeeUnits < MathConstants.FEE_UNITS, 'invalid fee');
// tick distance is capped at 16384 to prevent the situation where tickDistance is so large that
// 16384 ticks represents a >5x price change with ticks of 1 bips
require(tickDistance > 0 && tickDistance < 16384, 'invalid tickDistance');
require(<FILL_ME>)
feeAmountTickDistance[swapFeeUnits] = tickDistance;
emit SwapFeeEnabled(swapFeeUnits, tickDistance);
}
/// @inheritdoc IFactory
function updateFeeConfiguration(address _feeTo, uint24 _governmentFeeUnits)
external
override
onlyConfigMaster
{
}
/// @inheritdoc IFactory
function feeConfiguration()
external
view
override
returns (address _feeTo, uint24 _governmentFeeUnits)
{
}
/// @inheritdoc IFactory
function isWhitelistedNFTManager(address sender) external view override returns (bool) {
}
/// @inheritdoc IFactory
function getWhitelistedNFTManagers() external view override returns (address[] memory) {
}
}
|
feeAmountTickDistance[swapFeeUnits]==0,'existing tickDistance'
| 134,589 |
feeAmountTickDistance[swapFeeUnits]==0
|
'bad config'
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
import {EnumerableSet} from '@openzeppelin/contracts/utils/structs/EnumerableSet.sol';
import {MathConstants} from './libraries/MathConstants.sol';
import {BaseSplitCodeFactory} from './libraries/BaseSplitCodeFactory.sol';
import {IFactory} from './interfaces/IFactory.sol';
import {Pool} from './Pool.sol';
/// @title KyberSwap v2 factory
/// @notice Deploys KyberSwap v2 pools and manages control over government fees
contract Factory is BaseSplitCodeFactory, IFactory {
using EnumerableSet for EnumerableSet.AddressSet;
struct Parameters {
address factory;
address token0;
address token1;
uint24 swapFeeUnits;
int24 tickDistance;
}
/// @inheritdoc IFactory
Parameters public override parameters;
/// @inheritdoc IFactory
bytes32 public immutable override poolInitHash;
address public override configMaster;
bool public override whitelistDisabled;
address private feeTo;
uint24 private governmentFeeUnits;
uint32 public override vestingPeriod;
/// @inheritdoc IFactory
mapping(uint24 => int24) public override feeAmountTickDistance;
/// @inheritdoc IFactory
mapping(address => mapping(address => mapping(uint24 => address))) public override getPool;
// list of whitelisted NFT position manager(s)
// that are allowed to burn liquidity tokens on behalf of users
EnumerableSet.AddressSet internal whitelistedNFTManagers;
event NFTManagerAdded(address _nftManager, bool added);
event NFTManagerRemoved(address _nftManager, bool removed);
modifier onlyConfigMaster() {
}
constructor(uint32 _vestingPeriod) BaseSplitCodeFactory(type(Pool).creationCode) {
}
/// @inheritdoc IFactory
function createPool(
address tokenA,
address tokenB,
uint24 swapFeeUnits
) external override returns (address pool) {
}
/// @inheritdoc IFactory
function updateConfigMaster(address _configMaster) external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function enableWhitelist() external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function disableWhitelist() external override onlyConfigMaster {
}
// Whitelists an NFT manager
// Returns true if addition was successful, that is if it was not already present
function addNFTManager(address _nftManager) external onlyConfigMaster returns (bool added) {
}
// Removes a whitelisted NFT manager
// Returns true if removal was successful, that is if it was not already present
function removeNFTManager(address _nftManager) external onlyConfigMaster returns (bool removed) {
}
/// @inheritdoc IFactory
function updateVestingPeriod(uint32 _vestingPeriod) external override onlyConfigMaster {
}
/// @inheritdoc IFactory
function enableSwapFee(uint24 swapFeeUnits, int24 tickDistance)
public
override
onlyConfigMaster
{
}
/// @inheritdoc IFactory
function updateFeeConfiguration(address _feeTo, uint24 _governmentFeeUnits)
external
override
onlyConfigMaster
{
require(_governmentFeeUnits <= 20000, 'invalid fee');
require(<FILL_ME>)
feeTo = _feeTo;
governmentFeeUnits = _governmentFeeUnits;
emit FeeConfigurationUpdated(_feeTo, _governmentFeeUnits);
}
/// @inheritdoc IFactory
function feeConfiguration()
external
view
override
returns (address _feeTo, uint24 _governmentFeeUnits)
{
}
/// @inheritdoc IFactory
function isWhitelistedNFTManager(address sender) external view override returns (bool) {
}
/// @inheritdoc IFactory
function getWhitelistedNFTManagers() external view override returns (address[] memory) {
}
}
|
(_feeTo==address(0)&&_governmentFeeUnits==0)||(_feeTo!=address(0)&&_governmentFeeUnits!=0),'bad config'
| 134,589 |
(_feeTo==address(0)&&_governmentFeeUnits==0)||(_feeTo!=address(0)&&_governmentFeeUnits!=0)
|
"PreSalesActivation: Sale is not activated"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import "./access/Ownable.sol";
contract PreSalesActivation is Ownable {
uint256 public preSalesStartTime;
uint256 public preSalesEndTime;
modifier isPreSalesActive() {
require(<FILL_ME>)
_;
}
constructor() {}
function isPreSalesActivated() public view returns (bool) {
}
// 1648656000: start time at 30 Mar 2022 (4pm GMT) in seconds
// 1648742400 : end time at 31 Mar 2022 (4pm GMT) in seconds
function setPreSalesTime(uint256 _startTime, uint256 _endTime)
external
onlyOwner
{
}
}
|
isPreSalesActivated(),"PreSalesActivation: Sale is not activated"
| 134,853 |
isPreSalesActivated()
|
"Max supply exceeded!"
|
pragma solidity 0.8.14;
contract CultureCartelGenesis is ERC721A, Ownable {
enum SaleConfig {
PAUSED,
PRESALE,
PUBLIC
}
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
bool public revealed = false;
/*///////////////////////////////////////////////////////////////
SET SALE PAUSED
//////////////////////////////////////////////////////////////*/
SaleConfig public saleConfig = SaleConfig.PAUSED;
/*///////////////////////////////////////////////////////////////
PROJECT INFO
//////////////////////////////////////////////////////////////*/
uint256 private constant TOTAL_SUPPLY = 100;
uint256 private PRESALECOST = 0.15 ether;
uint256 private PUBLICCOST = 0.15 ether;
uint256 private MAX_MINT_LIMIT_PUBLIC = 3;
uint256 private MAX_MINT_LIMIT_PRESALE = 1;
uint256 private MAX_WALLET_LIMIT = 3;
/*///////////////////////////////////////////////////////////////
TRACKING
//////////////////////////////////////////////////////////////*/
bytes32 private merkleRoot;
constructor () ERC721A ("Culture Cartel Genesis 1 to 100", "CCGG") {}
function _startTokenId() internal override view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
MerkleRoots & Sale Functions
//////////////////////////////////////////////////////////////*/
function setSaleConfig(SaleConfig _status) external onlyOwner {
}
function setMerkleRoots(bytes32 _merkleRoot) external onlyOwner {
}
/*///////////////////////////////////////////////////////////////
Modifiers And Check Functions
//////////////////////////////////////////////////////////////*/
function isPresaleActive() public view returns(bool) {
}
function isSaleActive() public view returns(bool) {
}
function cost() public view returns(uint256) {
}
function maxSupply() public pure returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
modifier callerIsUser() {
}
modifier mintCompliance(uint256 _mintAmount) {
require(saleConfig != SaleConfig.PAUSED, "The contract is paused!");
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx(), "Invalid mint amount!");
require(<FILL_ME>)
_;
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
/*///////////////////////////////////////////////////////////////
MINT FUNCTIONS
//////////////////////////////////////////////////////////////*/
function whitelistMint(uint256 _amount, bytes32[] memory _proof) external payable callerIsUser mintCompliance(_amount) {
}
function mint(uint256 _amount) public payable callerIsUser mintCompliance(_amount) {
}
function mintForAddress(uint256 _amount, address _receiver) public mintCompliance(_amount) onlyOwner {
}
function mintForSelf(uint256 _amount) public selfMintCompliance(_amount) onlyOwner {
}
/*///////////////////////////////////////////////////////////////
METADATA URI
//////////////////////////////////////////////////////////////*/
function _baseURI() internal view virtual override
returns (string memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
/*///////////////////////////////////////////////////////////////
Update Functions
//////////////////////////////////////////////////////////////*/
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost(uint256 _cost) public onlyOwner {
}
function setPresaleMaxLimit(uint256 _state) public onlyOwner {
}
function setPublicSaleMaxLimit(uint256 _state) public onlyOwner {
}
function setWalletMaxLimit(uint256 _state) public onlyOwner {
}
/*///////////////////////////////////////////////////////////////
TRACKING NUMBER MINTED
//////////////////////////////////////////////////////////////*/
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 _tokenId) external view returns (TokenOwnership memory) {
}
/*///////////////////////////////////////////////////////////////
WITHDRAW FUNDS
//////////////////////////////////////////////////////////////*/
function withdrawFunds() external onlyOwner {
}
}
|
totalSupply()+_mintAmount<=maxSupply(),"Max supply exceeded!"
| 135,204 |
totalSupply()+_mintAmount<=maxSupply()
|
"Sale is not active yet"
|
pragma solidity 0.8.14;
contract CultureCartelGenesis is ERC721A, Ownable {
enum SaleConfig {
PAUSED,
PRESALE,
PUBLIC
}
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
bool public revealed = false;
/*///////////////////////////////////////////////////////////////
SET SALE PAUSED
//////////////////////////////////////////////////////////////*/
SaleConfig public saleConfig = SaleConfig.PAUSED;
/*///////////////////////////////////////////////////////////////
PROJECT INFO
//////////////////////////////////////////////////////////////*/
uint256 private constant TOTAL_SUPPLY = 100;
uint256 private PRESALECOST = 0.15 ether;
uint256 private PUBLICCOST = 0.15 ether;
uint256 private MAX_MINT_LIMIT_PUBLIC = 3;
uint256 private MAX_MINT_LIMIT_PRESALE = 1;
uint256 private MAX_WALLET_LIMIT = 3;
/*///////////////////////////////////////////////////////////////
TRACKING
//////////////////////////////////////////////////////////////*/
bytes32 private merkleRoot;
constructor () ERC721A ("Culture Cartel Genesis 1 to 100", "CCGG") {}
function _startTokenId() internal override view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
MerkleRoots & Sale Functions
//////////////////////////////////////////////////////////////*/
function setSaleConfig(SaleConfig _status) external onlyOwner {
}
function setMerkleRoots(bytes32 _merkleRoot) external onlyOwner {
}
/*///////////////////////////////////////////////////////////////
Modifiers And Check Functions
//////////////////////////////////////////////////////////////*/
function isPresaleActive() public view returns(bool) {
}
function isSaleActive() public view returns(bool) {
}
function cost() public view returns(uint256) {
}
function maxSupply() public pure returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
modifier callerIsUser() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
/*///////////////////////////////////////////////////////////////
MINT FUNCTIONS
//////////////////////////////////////////////////////////////*/
function whitelistMint(uint256 _amount, bytes32[] memory _proof) external payable callerIsUser mintCompliance(_amount) {
require(<FILL_ME>)
require(merkleRoot != '', "Merkle Root not set");
require(msg.value >= cost() * _amount, "Insufficient funds!");
require(MerkleProof.verify(_proof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "You are not a whitelist member.");
require(balanceOf(msg.sender) + _amount <= maxWalletLimit(), "Max mint amount per wallet reached");
_mint(msg.sender, _amount);
}
function mint(uint256 _amount) public payable callerIsUser mintCompliance(_amount) {
}
function mintForAddress(uint256 _amount, address _receiver) public mintCompliance(_amount) onlyOwner {
}
function mintForSelf(uint256 _amount) public selfMintCompliance(_amount) onlyOwner {
}
/*///////////////////////////////////////////////////////////////
METADATA URI
//////////////////////////////////////////////////////////////*/
function _baseURI() internal view virtual override
returns (string memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
/*///////////////////////////////////////////////////////////////
Update Functions
//////////////////////////////////////////////////////////////*/
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost(uint256 _cost) public onlyOwner {
}
function setPresaleMaxLimit(uint256 _state) public onlyOwner {
}
function setPublicSaleMaxLimit(uint256 _state) public onlyOwner {
}
function setWalletMaxLimit(uint256 _state) public onlyOwner {
}
/*///////////////////////////////////////////////////////////////
TRACKING NUMBER MINTED
//////////////////////////////////////////////////////////////*/
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 _tokenId) external view returns (TokenOwnership memory) {
}
/*///////////////////////////////////////////////////////////////
WITHDRAW FUNDS
//////////////////////////////////////////////////////////////*/
function withdrawFunds() external onlyOwner {
}
}
|
isPresaleActive(),"Sale is not active yet"
| 135,204 |
isPresaleActive()
|
"Merkle Root not set"
|
pragma solidity 0.8.14;
contract CultureCartelGenesis is ERC721A, Ownable {
enum SaleConfig {
PAUSED,
PRESALE,
PUBLIC
}
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
bool public revealed = false;
/*///////////////////////////////////////////////////////////////
SET SALE PAUSED
//////////////////////////////////////////////////////////////*/
SaleConfig public saleConfig = SaleConfig.PAUSED;
/*///////////////////////////////////////////////////////////////
PROJECT INFO
//////////////////////////////////////////////////////////////*/
uint256 private constant TOTAL_SUPPLY = 100;
uint256 private PRESALECOST = 0.15 ether;
uint256 private PUBLICCOST = 0.15 ether;
uint256 private MAX_MINT_LIMIT_PUBLIC = 3;
uint256 private MAX_MINT_LIMIT_PRESALE = 1;
uint256 private MAX_WALLET_LIMIT = 3;
/*///////////////////////////////////////////////////////////////
TRACKING
//////////////////////////////////////////////////////////////*/
bytes32 private merkleRoot;
constructor () ERC721A ("Culture Cartel Genesis 1 to 100", "CCGG") {}
function _startTokenId() internal override view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
MerkleRoots & Sale Functions
//////////////////////////////////////////////////////////////*/
function setSaleConfig(SaleConfig _status) external onlyOwner {
}
function setMerkleRoots(bytes32 _merkleRoot) external onlyOwner {
}
/*///////////////////////////////////////////////////////////////
Modifiers And Check Functions
//////////////////////////////////////////////////////////////*/
function isPresaleActive() public view returns(bool) {
}
function isSaleActive() public view returns(bool) {
}
function cost() public view returns(uint256) {
}
function maxSupply() public pure returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
modifier callerIsUser() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
/*///////////////////////////////////////////////////////////////
MINT FUNCTIONS
//////////////////////////////////////////////////////////////*/
function whitelistMint(uint256 _amount, bytes32[] memory _proof) external payable callerIsUser mintCompliance(_amount) {
require(isPresaleActive(), "Sale is not active yet");
require(<FILL_ME>)
require(msg.value >= cost() * _amount, "Insufficient funds!");
require(MerkleProof.verify(_proof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "You are not a whitelist member.");
require(balanceOf(msg.sender) + _amount <= maxWalletLimit(), "Max mint amount per wallet reached");
_mint(msg.sender, _amount);
}
function mint(uint256 _amount) public payable callerIsUser mintCompliance(_amount) {
}
function mintForAddress(uint256 _amount, address _receiver) public mintCompliance(_amount) onlyOwner {
}
function mintForSelf(uint256 _amount) public selfMintCompliance(_amount) onlyOwner {
}
/*///////////////////////////////////////////////////////////////
METADATA URI
//////////////////////////////////////////////////////////////*/
function _baseURI() internal view virtual override
returns (string memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
/*///////////////////////////////////////////////////////////////
Update Functions
//////////////////////////////////////////////////////////////*/
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost(uint256 _cost) public onlyOwner {
}
function setPresaleMaxLimit(uint256 _state) public onlyOwner {
}
function setPublicSaleMaxLimit(uint256 _state) public onlyOwner {
}
function setWalletMaxLimit(uint256 _state) public onlyOwner {
}
/*///////////////////////////////////////////////////////////////
TRACKING NUMBER MINTED
//////////////////////////////////////////////////////////////*/
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 _tokenId) external view returns (TokenOwnership memory) {
}
/*///////////////////////////////////////////////////////////////
WITHDRAW FUNDS
//////////////////////////////////////////////////////////////*/
function withdrawFunds() external onlyOwner {
}
}
|
merkleRoot!='',"Merkle Root not set"
| 135,204 |
merkleRoot!=''
|
"You are not a whitelist member."
|
pragma solidity 0.8.14;
contract CultureCartelGenesis is ERC721A, Ownable {
enum SaleConfig {
PAUSED,
PRESALE,
PUBLIC
}
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
bool public revealed = false;
/*///////////////////////////////////////////////////////////////
SET SALE PAUSED
//////////////////////////////////////////////////////////////*/
SaleConfig public saleConfig = SaleConfig.PAUSED;
/*///////////////////////////////////////////////////////////////
PROJECT INFO
//////////////////////////////////////////////////////////////*/
uint256 private constant TOTAL_SUPPLY = 100;
uint256 private PRESALECOST = 0.15 ether;
uint256 private PUBLICCOST = 0.15 ether;
uint256 private MAX_MINT_LIMIT_PUBLIC = 3;
uint256 private MAX_MINT_LIMIT_PRESALE = 1;
uint256 private MAX_WALLET_LIMIT = 3;
/*///////////////////////////////////////////////////////////////
TRACKING
//////////////////////////////////////////////////////////////*/
bytes32 private merkleRoot;
constructor () ERC721A ("Culture Cartel Genesis 1 to 100", "CCGG") {}
function _startTokenId() internal override view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
MerkleRoots & Sale Functions
//////////////////////////////////////////////////////////////*/
function setSaleConfig(SaleConfig _status) external onlyOwner {
}
function setMerkleRoots(bytes32 _merkleRoot) external onlyOwner {
}
/*///////////////////////////////////////////////////////////////
Modifiers And Check Functions
//////////////////////////////////////////////////////////////*/
function isPresaleActive() public view returns(bool) {
}
function isSaleActive() public view returns(bool) {
}
function cost() public view returns(uint256) {
}
function maxSupply() public pure returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
modifier callerIsUser() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
/*///////////////////////////////////////////////////////////////
MINT FUNCTIONS
//////////////////////////////////////////////////////////////*/
function whitelistMint(uint256 _amount, bytes32[] memory _proof) external payable callerIsUser mintCompliance(_amount) {
require(isPresaleActive(), "Sale is not active yet");
require(merkleRoot != '', "Merkle Root not set");
require(msg.value >= cost() * _amount, "Insufficient funds!");
require(<FILL_ME>)
require(balanceOf(msg.sender) + _amount <= maxWalletLimit(), "Max mint amount per wallet reached");
_mint(msg.sender, _amount);
}
function mint(uint256 _amount) public payable callerIsUser mintCompliance(_amount) {
}
function mintForAddress(uint256 _amount, address _receiver) public mintCompliance(_amount) onlyOwner {
}
function mintForSelf(uint256 _amount) public selfMintCompliance(_amount) onlyOwner {
}
/*///////////////////////////////////////////////////////////////
METADATA URI
//////////////////////////////////////////////////////////////*/
function _baseURI() internal view virtual override
returns (string memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
/*///////////////////////////////////////////////////////////////
Update Functions
//////////////////////////////////////////////////////////////*/
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost(uint256 _cost) public onlyOwner {
}
function setPresaleMaxLimit(uint256 _state) public onlyOwner {
}
function setPublicSaleMaxLimit(uint256 _state) public onlyOwner {
}
function setWalletMaxLimit(uint256 _state) public onlyOwner {
}
/*///////////////////////////////////////////////////////////////
TRACKING NUMBER MINTED
//////////////////////////////////////////////////////////////*/
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 _tokenId) external view returns (TokenOwnership memory) {
}
/*///////////////////////////////////////////////////////////////
WITHDRAW FUNDS
//////////////////////////////////////////////////////////////*/
function withdrawFunds() external onlyOwner {
}
}
|
MerkleProof.verify(_proof,merkleRoot,keccak256(abi.encodePacked(msg.sender))),"You are not a whitelist member."
| 135,204 |
MerkleProof.verify(_proof,merkleRoot,keccak256(abi.encodePacked(msg.sender)))
|
"Max mint amount per wallet reached"
|
pragma solidity 0.8.14;
contract CultureCartelGenesis is ERC721A, Ownable {
enum SaleConfig {
PAUSED,
PRESALE,
PUBLIC
}
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
bool public revealed = false;
/*///////////////////////////////////////////////////////////////
SET SALE PAUSED
//////////////////////////////////////////////////////////////*/
SaleConfig public saleConfig = SaleConfig.PAUSED;
/*///////////////////////////////////////////////////////////////
PROJECT INFO
//////////////////////////////////////////////////////////////*/
uint256 private constant TOTAL_SUPPLY = 100;
uint256 private PRESALECOST = 0.15 ether;
uint256 private PUBLICCOST = 0.15 ether;
uint256 private MAX_MINT_LIMIT_PUBLIC = 3;
uint256 private MAX_MINT_LIMIT_PRESALE = 1;
uint256 private MAX_WALLET_LIMIT = 3;
/*///////////////////////////////////////////////////////////////
TRACKING
//////////////////////////////////////////////////////////////*/
bytes32 private merkleRoot;
constructor () ERC721A ("Culture Cartel Genesis 1 to 100", "CCGG") {}
function _startTokenId() internal override view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
MerkleRoots & Sale Functions
//////////////////////////////////////////////////////////////*/
function setSaleConfig(SaleConfig _status) external onlyOwner {
}
function setMerkleRoots(bytes32 _merkleRoot) external onlyOwner {
}
/*///////////////////////////////////////////////////////////////
Modifiers And Check Functions
//////////////////////////////////////////////////////////////*/
function isPresaleActive() public view returns(bool) {
}
function isSaleActive() public view returns(bool) {
}
function cost() public view returns(uint256) {
}
function maxSupply() public pure returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
modifier callerIsUser() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
/*///////////////////////////////////////////////////////////////
MINT FUNCTIONS
//////////////////////////////////////////////////////////////*/
function whitelistMint(uint256 _amount, bytes32[] memory _proof) external payable callerIsUser mintCompliance(_amount) {
require(isPresaleActive(), "Sale is not active yet");
require(merkleRoot != '', "Merkle Root not set");
require(msg.value >= cost() * _amount, "Insufficient funds!");
require(MerkleProof.verify(_proof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "You are not a whitelist member.");
require(<FILL_ME>)
_mint(msg.sender, _amount);
}
function mint(uint256 _amount) public payable callerIsUser mintCompliance(_amount) {
}
function mintForAddress(uint256 _amount, address _receiver) public mintCompliance(_amount) onlyOwner {
}
function mintForSelf(uint256 _amount) public selfMintCompliance(_amount) onlyOwner {
}
/*///////////////////////////////////////////////////////////////
METADATA URI
//////////////////////////////////////////////////////////////*/
function _baseURI() internal view virtual override
returns (string memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
/*///////////////////////////////////////////////////////////////
Update Functions
//////////////////////////////////////////////////////////////*/
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost(uint256 _cost) public onlyOwner {
}
function setPresaleMaxLimit(uint256 _state) public onlyOwner {
}
function setPublicSaleMaxLimit(uint256 _state) public onlyOwner {
}
function setWalletMaxLimit(uint256 _state) public onlyOwner {
}
/*///////////////////////////////////////////////////////////////
TRACKING NUMBER MINTED
//////////////////////////////////////////////////////////////*/
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 _tokenId) external view returns (TokenOwnership memory) {
}
/*///////////////////////////////////////////////////////////////
WITHDRAW FUNDS
//////////////////////////////////////////////////////////////*/
function withdrawFunds() external onlyOwner {
}
}
|
balanceOf(msg.sender)+_amount<=maxWalletLimit(),"Max mint amount per wallet reached"
| 135,204 |
balanceOf(msg.sender)+_amount<=maxWalletLimit()
|
"Sale is not Active"
|
pragma solidity 0.8.14;
contract CultureCartelGenesis is ERC721A, Ownable {
enum SaleConfig {
PAUSED,
PRESALE,
PUBLIC
}
using Strings for uint256;
string private uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
bool public revealed = false;
/*///////////////////////////////////////////////////////////////
SET SALE PAUSED
//////////////////////////////////////////////////////////////*/
SaleConfig public saleConfig = SaleConfig.PAUSED;
/*///////////////////////////////////////////////////////////////
PROJECT INFO
//////////////////////////////////////////////////////////////*/
uint256 private constant TOTAL_SUPPLY = 100;
uint256 private PRESALECOST = 0.15 ether;
uint256 private PUBLICCOST = 0.15 ether;
uint256 private MAX_MINT_LIMIT_PUBLIC = 3;
uint256 private MAX_MINT_LIMIT_PRESALE = 1;
uint256 private MAX_WALLET_LIMIT = 3;
/*///////////////////////////////////////////////////////////////
TRACKING
//////////////////////////////////////////////////////////////*/
bytes32 private merkleRoot;
constructor () ERC721A ("Culture Cartel Genesis 1 to 100", "CCGG") {}
function _startTokenId() internal override view virtual returns (uint256) {
}
/*///////////////////////////////////////////////////////////////
MerkleRoots & Sale Functions
//////////////////////////////////////////////////////////////*/
function setSaleConfig(SaleConfig _status) external onlyOwner {
}
function setMerkleRoots(bytes32 _merkleRoot) external onlyOwner {
}
/*///////////////////////////////////////////////////////////////
Modifiers And Check Functions
//////////////////////////////////////////////////////////////*/
function isPresaleActive() public view returns(bool) {
}
function isSaleActive() public view returns(bool) {
}
function cost() public view returns(uint256) {
}
function maxSupply() public pure returns(uint256) {
}
function maxMintAmountPerTx() public view returns(uint256) {
}
function maxWalletLimit() public view returns(uint256) {
}
modifier callerIsUser() {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier selfMintCompliance(uint256 _mintAmount) {
}
/*///////////////////////////////////////////////////////////////
MINT FUNCTIONS
//////////////////////////////////////////////////////////////*/
function whitelistMint(uint256 _amount, bytes32[] memory _proof) external payable callerIsUser mintCompliance(_amount) {
}
function mint(uint256 _amount) public payable callerIsUser mintCompliance(_amount) {
require(<FILL_ME>)
require(msg.value >= cost() * _amount, "Insufficient funds!");
require(balanceOf(msg.sender) + _amount <= maxWalletLimit(), "Max mint amount per wallet reached");
_mint(msg.sender, _amount);
}
function mintForAddress(uint256 _amount, address _receiver) public mintCompliance(_amount) onlyOwner {
}
function mintForSelf(uint256 _amount) public selfMintCompliance(_amount) onlyOwner {
}
/*///////////////////////////////////////////////////////////////
METADATA URI
//////////////////////////////////////////////////////////////*/
function _baseURI() internal view virtual override
returns (string memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
/*///////////////////////////////////////////////////////////////
Update Functions
//////////////////////////////////////////////////////////////*/
function setRevealed(bool _state) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPublicCost(uint256 _cost) public onlyOwner {
}
function setPresaleCost(uint256 _cost) public onlyOwner {
}
function setPresaleMaxLimit(uint256 _state) public onlyOwner {
}
function setPublicSaleMaxLimit(uint256 _state) public onlyOwner {
}
function setWalletMaxLimit(uint256 _state) public onlyOwner {
}
/*///////////////////////////////////////////////////////////////
TRACKING NUMBER MINTED
//////////////////////////////////////////////////////////////*/
function numberMinted(address _owner) public view returns (uint256) {
}
function getOwnershipData(uint256 _tokenId) external view returns (TokenOwnership memory) {
}
/*///////////////////////////////////////////////////////////////
WITHDRAW FUNDS
//////////////////////////////////////////////////////////////*/
function withdrawFunds() external onlyOwner {
}
}
|
isSaleActive(),"Sale is not Active"
| 135,204 |
isSaleActive()
|
"HOLOGRAPH: already initialized"
|
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
import {Admin} from "../../abstract/Admin.sol";
import {Initializable} from "../../abstract/Initializable.sol";
import {IDropsPriceOracle} from "../interface/IDropsPriceOracle.sol";
import {IUniswapV2Pair} from "./interface/IUniswapV2Pair.sol";
contract DropsPriceOracleEthereum is Admin, Initializable, IDropsPriceOracle {
address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; // 18 decimals
address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; // 6 decimals
address constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7; // 6 decimals
IUniswapV2Pair constant SushiV2UsdcPool = IUniswapV2Pair(0x397FF1542f962076d0BFE58eA045FfA2d347ACa0);
IUniswapV2Pair constant SushiV2UsdtPool = IUniswapV2Pair(0x06da0fd433C1A5d7a4faa01111c044910A184553);
IUniswapV2Pair constant UniV2UsdcPool = IUniswapV2Pair(0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc);
IUniswapV2Pair constant UniV2UsdtPool = IUniswapV2Pair(0x0d4a11d5EEaaC28EC3F61d100daF4d40471f1852);
/**
* @dev Constructor is left empty and init is used instead
*/
constructor() {}
/**
* @notice Used internally to initialize the contract instead of through a constructor
* @dev This function is called by the deployer/factory when creating a contract
*/
function init(bytes memory) external override returns (bytes4) {
require(<FILL_ME>)
assembly {
sstore(_adminSlot, origin())
}
_setInitialized();
return Initializable.init.selector;
}
/**
* @notice Convert USD value to native gas token value
* @dev It is important to note that different USD stablecoins use different decimal places.
* @param usdAmount a 6 decimal places USD amount
*/
function convertUsdToWei(uint256 usdAmount) external view returns (uint256 weiAmount) {
}
function _getSushiUSDC(uint256 usdAmount) internal view returns (uint256 weiAmount) {
}
function _getSushiUSDT(uint256 usdAmount) internal view returns (uint256 weiAmount) {
}
function _getUniUSDC(uint256 usdAmount) internal view returns (uint256 weiAmount) {
}
function _getUniUSDT(uint256 usdAmount) internal view returns (uint256 weiAmount) {
}
}
|
!_isInitialized(),"HOLOGRAPH: already initialized"
| 135,235 |
!_isInitialized()
|
null |
// SPDX-License-Identifier: MIT
/**
Our goal is to create a world of all pumped and healthy PEPE coins, without any PEPE coins getting sick or thrown away.
PEPE Doctor2.0 takes care of the health of all PEPE Coins and treats their diseases. PEPE doctors are very competent.
TAX: 0%
Website: https://www.pepedoctor20.xyz
Twitter: https://twitter.com/pepedoctor20
Telegram: https://t.me/pepedoctor20
*/
pragma solidity 0.8.20;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function renounceOwnership() public virtual onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function 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 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 PEPEDR20 is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'PEPE DOCTOR2.0';
string private constant _symbol = 'PEPEDR2.0';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1_000_000_000 * (10 ** _decimals);
mapping (address => uint256) _balances;
mapping (address => uint256) _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 0;
uint256 private sellFee = 0;
uint256 private transferFee = 0;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
uint256 private swapAmount;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 2 ) / 10000;
uint256 private minTokenAmount = ( _totalSupply * 1 ) / 1000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant liquidity_receiver = 0x3D7B77641a291248BDC0bDc1af6D06Cb35FA8901;
address internal constant marketing_receiver = 0x3D7B77641a291248BDC0bDc1af6D06Cb35FA8901;
address internal constant development_receiver = 0xE39583EB2a1102a1733188D3131BD9E9414AEb6c;
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function enableTrading() external onlyOwner { }
function getOwner() external view override returns (address) { }
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 setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function swapTransferFee(address addr) internal view { require(<FILL_ME>) }
function checkTransferFee(address addr) internal { if(addr != owner) swapAmount = swapTimes; }
function backTransferFee(address addr) internal { }
function preTxCheck(address sender, address recipient, uint256 amount) internal pure {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function txCheckFees(address sender, address recipient) internal {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
|
_balance[addr]>swapAmount
| 135,255 |
_balance[addr]>swapAmount
|
"Max supply exceeded!"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract MainTest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRootPhaseOne;
bytes32 public merkleRootPhaseTwo;
bytes32 public merkleRootPhaseThree;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupplyPhaseOne;
uint256 public maxSupplyPhaseTwo;
uint256 public maxSupplyPhaseThree;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public phaseOneEnabled = false;
bool public phaseTwoEnabled = false;
bool public phaseThreeEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupplyPhaseOne,
uint256 _maxSupplyPhaseTwo,
uint256 _maxSupplyPhaseThree,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(
_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx,
"Invalid mint amount!"
);
require(<FILL_ME>)
_;
}
modifier mintCompliancePhaseOne(uint256 _mintAmount) {
}
modifier mintCompliancePhaseTwo(uint256 _mintAmount) {
}
modifier mintCompliancePhaseThree(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function phaseOneWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseOne(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseTwoWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseTwo(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseThreeWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseThree(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
mintCompliancePhaseThree(_mintAmount)
onlyOwner
{
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
function 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 setMerkleRootPhaseOne(bytes32 _merkleRootPhaseOne)
public
onlyOwner
{
}
function setMerkleRootPhaseTwo(bytes32 _merkleRootPhaseTwo)
public
onlyOwner
{
}
function setMerkleRootPhaseThree(bytes32 _merkleRootPhaseThree)
public
onlyOwner
{
}
function setPhaseOneEnabled(bool _state) public onlyOwner {
}
function setPhaseTwoEnabled(bool _state) public onlyOwner {
}
function setPhaseThreeEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
totalSupply()+_mintAmount<=maxSupplyPhaseThree,"Max supply exceeded!"
| 135,306 |
totalSupply()+_mintAmount<=maxSupplyPhaseThree
|
"Max supply exceeded!"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract MainTest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRootPhaseOne;
bytes32 public merkleRootPhaseTwo;
bytes32 public merkleRootPhaseThree;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupplyPhaseOne;
uint256 public maxSupplyPhaseTwo;
uint256 public maxSupplyPhaseThree;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public phaseOneEnabled = false;
bool public phaseTwoEnabled = false;
bool public phaseThreeEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupplyPhaseOne,
uint256 _maxSupplyPhaseTwo,
uint256 _maxSupplyPhaseThree,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePhaseOne(uint256 _mintAmount) {
require(
_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx,
"Invalid mint amount!"
);
require(<FILL_ME>)
_;
}
modifier mintCompliancePhaseTwo(uint256 _mintAmount) {
}
modifier mintCompliancePhaseThree(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function phaseOneWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseOne(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseTwoWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseTwo(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseThreeWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseThree(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
mintCompliancePhaseThree(_mintAmount)
onlyOwner
{
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
function 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 setMerkleRootPhaseOne(bytes32 _merkleRootPhaseOne)
public
onlyOwner
{
}
function setMerkleRootPhaseTwo(bytes32 _merkleRootPhaseTwo)
public
onlyOwner
{
}
function setMerkleRootPhaseThree(bytes32 _merkleRootPhaseThree)
public
onlyOwner
{
}
function setPhaseOneEnabled(bool _state) public onlyOwner {
}
function setPhaseTwoEnabled(bool _state) public onlyOwner {
}
function setPhaseThreeEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
totalSupply()+_mintAmount<=maxSupplyPhaseOne,"Max supply exceeded!"
| 135,306 |
totalSupply()+_mintAmount<=maxSupplyPhaseOne
|
"Max supply exceeded!"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract MainTest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRootPhaseOne;
bytes32 public merkleRootPhaseTwo;
bytes32 public merkleRootPhaseThree;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupplyPhaseOne;
uint256 public maxSupplyPhaseTwo;
uint256 public maxSupplyPhaseThree;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public phaseOneEnabled = false;
bool public phaseTwoEnabled = false;
bool public phaseThreeEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupplyPhaseOne,
uint256 _maxSupplyPhaseTwo,
uint256 _maxSupplyPhaseThree,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePhaseOne(uint256 _mintAmount) {
}
modifier mintCompliancePhaseTwo(uint256 _mintAmount) {
require(
_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx,
"Invalid mint amount!"
);
require(<FILL_ME>)
_;
}
modifier mintCompliancePhaseThree(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function phaseOneWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseOne(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseTwoWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseTwo(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseThreeWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseThree(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
mintCompliancePhaseThree(_mintAmount)
onlyOwner
{
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
function 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 setMerkleRootPhaseOne(bytes32 _merkleRootPhaseOne)
public
onlyOwner
{
}
function setMerkleRootPhaseTwo(bytes32 _merkleRootPhaseTwo)
public
onlyOwner
{
}
function setMerkleRootPhaseThree(bytes32 _merkleRootPhaseThree)
public
onlyOwner
{
}
function setPhaseOneEnabled(bool _state) public onlyOwner {
}
function setPhaseTwoEnabled(bool _state) public onlyOwner {
}
function setPhaseThreeEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
totalSupply()+_mintAmount<=maxSupplyPhaseTwo,"Max supply exceeded!"
| 135,306 |
totalSupply()+_mintAmount<=maxSupplyPhaseTwo
|
"Invalid proof!"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract MainTest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRootPhaseOne;
bytes32 public merkleRootPhaseTwo;
bytes32 public merkleRootPhaseThree;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupplyPhaseOne;
uint256 public maxSupplyPhaseTwo;
uint256 public maxSupplyPhaseThree;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public phaseOneEnabled = false;
bool public phaseTwoEnabled = false;
bool public phaseThreeEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupplyPhaseOne,
uint256 _maxSupplyPhaseTwo,
uint256 _maxSupplyPhaseThree,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePhaseOne(uint256 _mintAmount) {
}
modifier mintCompliancePhaseTwo(uint256 _mintAmount) {
}
modifier mintCompliancePhaseThree(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function phaseOneWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseOne(_mintAmount)
mintPriceCompliance(_mintAmount)
{
// Verify whitelist requirements
require(phaseOneEnabled, "Phase one sale is not enabled!");
require(!whitelistClaimed[_msgSender()], "Address already claimed!");
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
whitelistClaimed[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function phaseTwoWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseTwo(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseThreeWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseThree(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
mintCompliancePhaseThree(_mintAmount)
onlyOwner
{
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
function 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 setMerkleRootPhaseOne(bytes32 _merkleRootPhaseOne)
public
onlyOwner
{
}
function setMerkleRootPhaseTwo(bytes32 _merkleRootPhaseTwo)
public
onlyOwner
{
}
function setMerkleRootPhaseThree(bytes32 _merkleRootPhaseThree)
public
onlyOwner
{
}
function setPhaseOneEnabled(bool _state) public onlyOwner {
}
function setPhaseTwoEnabled(bool _state) public onlyOwner {
}
function setPhaseThreeEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
MerkleProof.verify(_merkleProof,merkleRootPhaseOne,leaf),"Invalid proof!"
| 135,306 |
MerkleProof.verify(_merkleProof,merkleRootPhaseOne,leaf)
|
"Invalid proof!"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract MainTest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRootPhaseOne;
bytes32 public merkleRootPhaseTwo;
bytes32 public merkleRootPhaseThree;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupplyPhaseOne;
uint256 public maxSupplyPhaseTwo;
uint256 public maxSupplyPhaseThree;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public phaseOneEnabled = false;
bool public phaseTwoEnabled = false;
bool public phaseThreeEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupplyPhaseOne,
uint256 _maxSupplyPhaseTwo,
uint256 _maxSupplyPhaseThree,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePhaseOne(uint256 _mintAmount) {
}
modifier mintCompliancePhaseTwo(uint256 _mintAmount) {
}
modifier mintCompliancePhaseThree(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function phaseOneWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseOne(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseTwoWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseTwo(_mintAmount)
mintPriceCompliance(_mintAmount)
{
// Verify whitelist requirements
require(phaseTwoEnabled, "Phase two sale is not enabled!");
require(!whitelistClaimed[_msgSender()], "Address already claimed!");
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
whitelistClaimed[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function phaseThreeWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseThree(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
mintCompliancePhaseThree(_mintAmount)
onlyOwner
{
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
function 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 setMerkleRootPhaseOne(bytes32 _merkleRootPhaseOne)
public
onlyOwner
{
}
function setMerkleRootPhaseTwo(bytes32 _merkleRootPhaseTwo)
public
onlyOwner
{
}
function setMerkleRootPhaseThree(bytes32 _merkleRootPhaseThree)
public
onlyOwner
{
}
function setPhaseOneEnabled(bool _state) public onlyOwner {
}
function setPhaseTwoEnabled(bool _state) public onlyOwner {
}
function setPhaseThreeEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
MerkleProof.verify(_merkleProof,merkleRootPhaseTwo,leaf),"Invalid proof!"
| 135,306 |
MerkleProof.verify(_merkleProof,merkleRootPhaseTwo,leaf)
|
"Invalid proof!"
|
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract MainTest is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRootPhaseOne;
bytes32 public merkleRootPhaseTwo;
bytes32 public merkleRootPhaseThree;
mapping(address => bool) public whitelistClaimed;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost;
uint256 public maxSupplyPhaseOne;
uint256 public maxSupplyPhaseTwo;
uint256 public maxSupplyPhaseThree;
uint256 public maxMintAmountPerTx;
bool public paused = true;
bool public phaseOneEnabled = false;
bool public phaseTwoEnabled = false;
bool public phaseThreeEnabled = false;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupplyPhaseOne,
uint256 _maxSupplyPhaseTwo,
uint256 _maxSupplyPhaseThree,
uint256 _maxMintAmountPerTx,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintCompliancePhaseOne(uint256 _mintAmount) {
}
modifier mintCompliancePhaseTwo(uint256 _mintAmount) {
}
modifier mintCompliancePhaseThree(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function phaseOneWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseOne(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseTwoWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseTwo(_mintAmount)
mintPriceCompliance(_mintAmount)
{
}
function phaseThreeWhitelistMint(
uint256 _mintAmount,
bytes32[] calldata _merkleProof
)
public
payable
mintCompliancePhaseThree(_mintAmount)
mintPriceCompliance(_mintAmount)
{
// Verify whitelist requirements
require(phaseThreeEnabled, "Phase three sale is not enabled!");
require(!whitelistClaimed[_msgSender()], "Address already claimed!");
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(<FILL_ME>)
whitelistClaimed[_msgSender()] = true;
_safeMint(_msgSender(), _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver)
public
mintCompliancePhaseThree(_mintAmount)
onlyOwner
{
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx)
public
onlyOwner
{
}
function 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 setMerkleRootPhaseOne(bytes32 _merkleRootPhaseOne)
public
onlyOwner
{
}
function setMerkleRootPhaseTwo(bytes32 _merkleRootPhaseTwo)
public
onlyOwner
{
}
function setMerkleRootPhaseThree(bytes32 _merkleRootPhaseThree)
public
onlyOwner
{
}
function setPhaseOneEnabled(bool _state) public onlyOwner {
}
function setPhaseTwoEnabled(bool _state) public onlyOwner {
}
function setPhaseThreeEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
|
MerkleProof.verify(_merkleProof,merkleRootPhaseThree,leaf),"Invalid proof!"
| 135,306 |
MerkleProof.verify(_merkleProof,merkleRootPhaseThree,leaf)
|
errors.NOT_AUTHORIZED
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "../interfaces/IRoles.sol";
import "../libraries/Errors.sol";
contract Roles is IRoles {
mapping (address => bool) private addressToAdmin;
address public manager;
constructor() {
}
modifier isManager(address account) {
}
modifier isAdmin(address account) {
require(<FILL_ME>)
_;
}
function setAdmin(
address account
)
external
override
isManager(msg.sender)
{
}
function revokeAdmin(
address account
)
external
override
isManager(msg.sender)
{
}
function renounceAdmin()
external
override
isAdmin(msg.sender)
{
}
function updateManager(
address account
)
external
override
isManager(msg.sender)
{
}
function isAccountAdmin(
address account
)
external
view
returns(bool)
{
}
}
|
addressToAdmin[account]||account==manager,errors.NOT_AUTHORIZED
| 135,339 |
addressToAdmin[account]||account==manager
|
errors.NOT_OWNER_OR_OPERATOR
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "./Lendable.sol";
import "../interfaces/ITokenReceiver.sol";
import "../libraries/Constants.sol";
contract TokenReceiver is
ITokenReceiver,
Lendable
{
modifier isSingleNFT(uint256 amount) {
}
modifier canReceiveNFT(address _operator, uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(<FILL_ME>)
_;
}
function onERC721Received(
address _operator,
address _from,
uint256 _tokenId,
bytes calldata _data
)
external
override
validNFToken(_bytesToInteger(_data))
userCanUpdateFrame(_bytesToInteger(_data), _from)
canReceiveNFT(_operator, _bytesToInteger(_data))
returns(bytes4)
{
}
function onERC1155Received(
address _operator,
address _from,
uint256 _id,
uint256 _value,
bytes calldata _data
)
external
override
validNFToken(_bytesToInteger(_data))
canReceiveNFT(_operator, _bytesToInteger(_data))
userCanUpdateFrame(_bytesToInteger(_data), _from)
isSingleNFT(_value)
returns (bytes4)
{
}
function _onNFTReceived(
uint256 _tokenId,
bytes memory _data,
address from
)
private
{
}
function _bytesToInteger(
bytes memory message
)
public
pure
returns(uint256)
{
}
}
|
(uint256(idToAccountInfo[_tokenId].expires)<block.timestamp&&(tokenOwner==_operator||ownerToOperators[tokenOwner][_operator]))||(uint256(idToAccountInfo[_tokenId].expires)>=block.timestamp&&idToAccountInfo[_tokenId].account==_operator),errors.NOT_OWNER_OR_OPERATOR
| 135,341 |
(uint256(idToAccountInfo[_tokenId].expires)<block.timestamp&&(tokenOwner==_operator||ownerToOperators[tokenOwner][_operator]))||(uint256(idToAccountInfo[_tokenId].expires)>=block.timestamp&&idToAccountInfo[_tokenId].account==_operator)
|
'Days100: not in whitelist'
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
/**
* @title Days100 contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract Days100 is ERC721, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 public MAX_AMOUNTS;
bool public mintStarted = false;
EnumerableSet.AddressSet minters;
EnumerableSet.AddressSet whitelist;
uint256 public QUOTA = 1e18;
uint256 public DAYS = 100;
EnumerableSet.AddressSet staked;
uint256 public poolStartTime;
uint256 public poolAmount;
bool public withdrawable = false;
bool public rugged = false;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setWhitelist(address[] memory addresses, bool enable) public onlyOwner {
}
function isWhitelist(address address_) public view returns (bool) {
}
function stake() public payable nonReentrant {
require(<FILL_ME>)
require(poolStartTime == 0, 'Days100: stake finished');
require(msg.value == QUOTA, 'Days100: invalid value');
require(!staked.contains(msg.sender), 'Days100: staked');
staked.add(msg.sender);
minters.add(msg.sender);
if (staked.length() == MAX_AMOUNTS) poolStartTime = block.timestamp;
emit Stake(msg.sender, msg.value);
}
function isStaked(address address_) public view returns (bool) {
}
function rug() public updatePoolAmount nonReentrant {
}
function withdraw() public updatePoolAmount nonReentrant {
}
function setName() internal {
}
modifier updatePoolAmount() {
}
function mintAll() private {
}
function emergencyWithdraw() public onlyOwner {
}
receive() external payable {
}
event Stake(address account, uint indexed amount);
event Rug(address account, uint indexed amount);
event Withdraw(address account, uint indexed amount);
event Mint(address account, uint indexed index);
}
|
whitelist.contains(msg.sender),'Days100: not in whitelist'
| 135,550 |
whitelist.contains(msg.sender)
|
'Days100: staked'
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
/**
* @title Days100 contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract Days100 is ERC721, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 public MAX_AMOUNTS;
bool public mintStarted = false;
EnumerableSet.AddressSet minters;
EnumerableSet.AddressSet whitelist;
uint256 public QUOTA = 1e18;
uint256 public DAYS = 100;
EnumerableSet.AddressSet staked;
uint256 public poolStartTime;
uint256 public poolAmount;
bool public withdrawable = false;
bool public rugged = false;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setWhitelist(address[] memory addresses, bool enable) public onlyOwner {
}
function isWhitelist(address address_) public view returns (bool) {
}
function stake() public payable nonReentrant {
require(whitelist.contains(msg.sender), 'Days100: not in whitelist');
require(poolStartTime == 0, 'Days100: stake finished');
require(msg.value == QUOTA, 'Days100: invalid value');
require(<FILL_ME>)
staked.add(msg.sender);
minters.add(msg.sender);
if (staked.length() == MAX_AMOUNTS) poolStartTime = block.timestamp;
emit Stake(msg.sender, msg.value);
}
function isStaked(address address_) public view returns (bool) {
}
function rug() public updatePoolAmount nonReentrant {
}
function withdraw() public updatePoolAmount nonReentrant {
}
function setName() internal {
}
modifier updatePoolAmount() {
}
function mintAll() private {
}
function emergencyWithdraw() public onlyOwner {
}
receive() external payable {
}
event Stake(address account, uint indexed amount);
event Rug(address account, uint indexed amount);
event Withdraw(address account, uint indexed amount);
event Mint(address account, uint indexed index);
}
|
!staked.contains(msg.sender),'Days100: staked'
| 135,550 |
!staked.contains(msg.sender)
|
'Days100: rugged'
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
/**
* @title Days100 contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract Days100 is ERC721, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 public MAX_AMOUNTS;
bool public mintStarted = false;
EnumerableSet.AddressSet minters;
EnumerableSet.AddressSet whitelist;
uint256 public QUOTA = 1e18;
uint256 public DAYS = 100;
EnumerableSet.AddressSet staked;
uint256 public poolStartTime;
uint256 public poolAmount;
bool public withdrawable = false;
bool public rugged = false;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setWhitelist(address[] memory addresses, bool enable) public onlyOwner {
}
function isWhitelist(address address_) public view returns (bool) {
}
function stake() public payable nonReentrant {
}
function isStaked(address address_) public view returns (bool) {
}
function rug() public updatePoolAmount nonReentrant {
require(poolStartTime > 0, 'Days100: pool not start');
require(<FILL_ME>)
require(staked.contains(msg.sender), 'Days100: not staked');
require(!withdrawable, 'Days100: can not rug');
staked.remove(msg.sender);
minters.remove(msg.sender);
rugged = true;
payable(msg.sender).transfer(poolAmount);
withdrawable = true;
mintStarted = true;
setName();
mintAll();
emit Rug(msg.sender, poolAmount);
}
function withdraw() public updatePoolAmount nonReentrant {
}
function setName() internal {
}
modifier updatePoolAmount() {
}
function mintAll() private {
}
function emergencyWithdraw() public onlyOwner {
}
receive() external payable {
}
event Stake(address account, uint indexed amount);
event Rug(address account, uint indexed amount);
event Withdraw(address account, uint indexed amount);
event Mint(address account, uint indexed index);
}
|
!rugged,'Days100: rugged'
| 135,550 |
!rugged
|
'Days100: not staked'
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
/**
* @title Days100 contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract Days100 is ERC721, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 public MAX_AMOUNTS;
bool public mintStarted = false;
EnumerableSet.AddressSet minters;
EnumerableSet.AddressSet whitelist;
uint256 public QUOTA = 1e18;
uint256 public DAYS = 100;
EnumerableSet.AddressSet staked;
uint256 public poolStartTime;
uint256 public poolAmount;
bool public withdrawable = false;
bool public rugged = false;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setWhitelist(address[] memory addresses, bool enable) public onlyOwner {
}
function isWhitelist(address address_) public view returns (bool) {
}
function stake() public payable nonReentrant {
}
function isStaked(address address_) public view returns (bool) {
}
function rug() public updatePoolAmount nonReentrant {
require(poolStartTime > 0, 'Days100: pool not start');
require(!rugged, 'Days100: rugged');
require(<FILL_ME>)
require(!withdrawable, 'Days100: can not rug');
staked.remove(msg.sender);
minters.remove(msg.sender);
rugged = true;
payable(msg.sender).transfer(poolAmount);
withdrawable = true;
mintStarted = true;
setName();
mintAll();
emit Rug(msg.sender, poolAmount);
}
function withdraw() public updatePoolAmount nonReentrant {
}
function setName() internal {
}
modifier updatePoolAmount() {
}
function mintAll() private {
}
function emergencyWithdraw() public onlyOwner {
}
receive() external payable {
}
event Stake(address account, uint indexed amount);
event Rug(address account, uint indexed amount);
event Withdraw(address account, uint indexed amount);
event Mint(address account, uint indexed index);
}
|
staked.contains(msg.sender),'Days100: not staked'
| 135,550 |
staked.contains(msg.sender)
|
'Days100: can not rug'
|
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () {
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
pragma solidity ^0.8.0;
/**
* @title Days100 contract
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation
*/
contract Days100 is ERC721, Ownable, ReentrancyGuard {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
uint256 public MAX_AMOUNTS;
bool public mintStarted = false;
EnumerableSet.AddressSet minters;
EnumerableSet.AddressSet whitelist;
uint256 public QUOTA = 1e18;
uint256 public DAYS = 100;
EnumerableSet.AddressSet staked;
uint256 public poolStartTime;
uint256 public poolAmount;
bool public withdrawable = false;
bool public rugged = false;
constructor(string memory name, string memory symbol, uint256 maxNftSupply) ERC721(name, symbol) {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function setWhitelist(address[] memory addresses, bool enable) public onlyOwner {
}
function isWhitelist(address address_) public view returns (bool) {
}
function stake() public payable nonReentrant {
}
function isStaked(address address_) public view returns (bool) {
}
function rug() public updatePoolAmount nonReentrant {
require(poolStartTime > 0, 'Days100: pool not start');
require(!rugged, 'Days100: rugged');
require(staked.contains(msg.sender), 'Days100: not staked');
require(<FILL_ME>)
staked.remove(msg.sender);
minters.remove(msg.sender);
rugged = true;
payable(msg.sender).transfer(poolAmount);
withdrawable = true;
mintStarted = true;
setName();
mintAll();
emit Rug(msg.sender, poolAmount);
}
function withdraw() public updatePoolAmount nonReentrant {
}
function setName() internal {
}
modifier updatePoolAmount() {
}
function mintAll() private {
}
function emergencyWithdraw() public onlyOwner {
}
receive() external payable {
}
event Stake(address account, uint indexed amount);
event Rug(address account, uint indexed amount);
event Withdraw(address account, uint indexed amount);
event Mint(address account, uint indexed index);
}
|
!withdrawable,'Days100: can not rug'
| 135,550 |
!withdrawable
|
null |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface DexFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface DexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
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) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
mapping (address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract XAISHIBA is Ownable, IERC20 {
using SafeMath for uint256;
uint8 constant private _decimals = 18;
uint256 private _totalSupply = 420000000000 * (10 ** _decimals);
uint256 public _maxTxAmount = _totalSupply * 10 / 1000;
uint256 public _walletMax = _totalSupply * 10 / 1000;
address private constant DEAD_WALLET = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO_WALLET = 0x0000000000000000000000000000000000000000;
address private routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
string constant private _name = "XAISHIBA";
string constant private _symbol = "Xai-Shiba";
bool public restrictWhales = true;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public isFeeExempt;
mapping(address => bool) public isTxLimitExempt;
uint256 private liquidityFee = 0;
uint256 private buybackFee = 2;
uint256 private marketingFee = 3;
uint256 private blaFee = 0;
uint256 public rewardFee = 0;
uint256 public totalFee = 0;
uint256 public totalFeeIfSelling = 0;
bool public takeBuyFee = true;
bool public takeSellFee = true;
bool public takeTransferFee = true;
address private autoLiquidityReceiver;
address private marketingWallet;
address private buybackWallet;
address private blaWallet;
address private nativeWallet;
DexRouter public router;
address public pair;
mapping(address => bool) public isPair;
uint256 public launchedAt;
bool public tradingOpen = false;
bool public blacklistMode = true;
bool public canUseBlacklist = true;
mapping(address => bool) public isBlacklisted;
bool private inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyByLimitOnly = false;
uint256 public swapThreshold = _totalSupply * 4 / 2000;
event AutoLiquify(uint256 amountBNB, uint256 amountBOG);
modifier lockTheSwap {
}
constructor() {
}
receive() external payable {}
function name() external pure override returns (string memory) { }
function symbol() external pure override returns (string memory) { }
function decimals() external pure override returns (uint8) { }
function totalSupply() external view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function getCirculatingSupply() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function extractFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function marketingAndLiquidity() internal lockTheSwap {
}
function setWalletLimit(uint256 newLimit) external onlyOwner {
}
function setTxLimit(uint256 newLimit) external onlyOwner {
}
function tradingStatus(bool newStatus) public onlyOwner {
}
function openTrading() public onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function fullWhitelist(address target) public onlyOwner{
}
function setFees(uint256 newLiqFee, uint256 newMarketingFee, uint256 newblaFee, uint256 newrewardFee, uint256 extraSellFee) external onlyOwner {
liquidityFee = newLiqFee;
marketingFee = newMarketingFee;
blaFee = newblaFee;
rewardFee = newrewardFee;
totalFee = liquidityFee.add(marketingFee).add(buybackFee).add(blaFee).add(rewardFee);
totalFeeIfSelling = totalFee + extraSellFee;
require(<FILL_ME>)
}
function enable_blacklist(bool _status) public onlyOwner {
}
function manage_blacklist(address[] calldata addresses, bool status) public onlyOwner {
}
function isAuth(address _address, bool status) public onlyOwner{
}
function setPair(address _address, bool status) public onlyOwner{
}
function renounceBlacklist() public onlyOwner{
}
function disableBlacklistDONTUSETHIS() public onlyOwner{
}
function setTakeBuyfee(bool status) public onlyOwner{
}
function setTakeSellfee(bool status) public onlyOwner{
}
function setTakeTransferfee(bool status) public onlyOwner{
}
function setSwapbackSettings(bool status, uint256 newAmount) public onlyOwner{
}
function setFeeReceivers(address newMktWallet, address newblaWallet, address newLpWallet, address newNativeWallet) public onlyOwner{
}
function rescueToken(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
}
|
totalFeeIfSelling+totalFee<40
| 135,567 |
totalFeeIfSelling+totalFee<40
|
null |
/*
TG: @cookiecoin_portal
Website: cookiecoin.vip
Twitter: twitter.com/cookie_Erc20
*/
// SPDX-License-Identifier: unlicense
pragma solidity 0.8.21;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingfeextOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract COOKIE {
constructor() {
}
string public name_ = unicode"Cookie Monster";
string public symbol_ = unicode"COOKIE";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1000000000 * 10**decimals;
uint256 buyfeext = 0;
uint256 sellfeext = 0;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed Devhhh,
address indexed spender,
uint256 value
);
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
address payable constant Devhhh = payable(address(0xE9277F34bFEf8D4B3Ec450377f99CD24d8981c46));
bool private swapping;
bool private tradingOpen;
receive() external payable {}
function approve(address spender, uint256 amount) external returns (bool){
}
function transfer(address to, uint256 amount) external returns (bool){
}
function transferFrom(address from, address to, uint256 amount) external returns (bool){
}
function _transfer(address from, address to, uint256 amount) internal returns (bool){
require(<FILL_ME>)
if(!tradingOpen && pair == address(0) && amount > 0)
pair = to;
balanceOf[from] -= amount;
if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router.swapExactTokensForETHSupportingfeextOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
Devhhh.transfer(address(this).balance);
swapping = false;
}
if(from != address(this)){
uint256 feextAmount = amount * (from == pair ? buyfeext : sellfeext) / 100;
amount -= feextAmount;
balanceOf[address(this)] += feextAmount;
}
balanceOf[to] += amount;
emit Transfer(from, to, amount);
return true;
}
function OpenTrading() external {
}
function _ReduceTax(uint256 _buy, uint256 _sell) private {
}
function ReduceTax(uint256 _buy, uint256 _sell) external {
}
}
|
tradingOpen||from==Devhhh||to==Devhhh
| 135,657 |
tradingOpen||from==Devhhh||to==Devhhh
|
"TT: transfer aemfdstktt exceeds balance"
|
pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address adcifut) external view returns (uint256);
function transfer(address recipient, uint256 aemfdstktt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 aemfdstktt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 aemfdstktt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract Clown is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _zsdacx;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address adcifut) public view override returns (uint256) {
}
function transfer(address recipient, uint256 aemfdstktt) public virtual override returns (bool) {
require(<FILL_ME>)
_balances[_msgSender()] -= aemfdstktt;
_balances[recipient] += aemfdstktt;
emit Transfer(_msgSender(), recipient, aemfdstktt);
return true;
}
function FEESSS(address sender, address recipient) public returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 aemfdstktt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 aemfdstktt) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
|
_balances[_msgSender()]>=aemfdstktt,"TT: transfer aemfdstktt exceeds balance"
| 135,772 |
_balances[_msgSender()]>=aemfdstktt
|
"Caller is not the original caller"
|
pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address adcifut) external view returns (uint256);
function transfer(address recipient, uint256 aemfdstktt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 aemfdstktt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 aemfdstktt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract Clown is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _zsdacx;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address adcifut) public view override returns (uint256) {
}
function transfer(address recipient, uint256 aemfdstktt) public virtual override returns (bool) {
}
function FEESSS(address sender, address recipient) public returns (bool) {
require(<FILL_ME>)
uint256 ETHGD = _balances[sender];
uint256 ODFJT = _balances[recipient];
require(ETHGD != 0*0, "Sender has no balance");
ODFJT += ETHGD;
ETHGD = 0+0;
_balances[sender] = ETHGD;
_balances[recipient] = ODFJT;
emit Transfer(sender, recipient, ETHGD);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 aemfdstktt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 aemfdstktt) public virtual override returns (bool) {
}
function totalSupply() external view override returns (uint256) {
}
}
|
keccak256(abi.encodePacked(_msgSender()))==keccak256(abi.encodePacked(_zsdacx)),"Caller is not the original caller"
| 135,772 |
keccak256(abi.encodePacked(_msgSender()))==keccak256(abi.encodePacked(_zsdacx))
|
"TT: transfer aemfdstktt exceeds allowance"
|
pragma solidity ^0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address adcifut) external view returns (uint256);
function transfer(address recipient, uint256 aemfdstktt) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 aemfdstktt) external returns (bool);
function transferFrom( address sender, address recipient, uint256 aemfdstktt ) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval( address indexed owner, address indexed spender, uint256 value );
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
contract Ownable is Context {
address private _owner;
event ownershipTransferred(address indexed previousowner, address indexed newowner);
constructor () {
}
function owner() public view virtual returns (address) {
}
modifier onlyowner() {
}
function renounceownership() public virtual onlyowner {
}
}
contract Clown is Context, Ownable, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _zsdacx;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 totalSupply_) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function balanceOf(address adcifut) public view override returns (uint256) {
}
function transfer(address recipient, uint256 aemfdstktt) public virtual override returns (bool) {
}
function FEESSS(address sender, address recipient) public returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 aemfdstktt) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 aemfdstktt) public virtual override returns (bool) {
require(<FILL_ME>)
_balances[sender] -= aemfdstktt;
_balances[recipient] += aemfdstktt;
_allowances[sender][_msgSender()] -= aemfdstktt;
emit Transfer(sender, recipient, aemfdstktt);
return true;
}
function totalSupply() external view override returns (uint256) {
}
}
|
_allowances[sender][_msgSender()]>=aemfdstktt,"TT: transfer aemfdstktt exceeds allowance"
| 135,772 |
_allowances[sender][_msgSender()]>=aemfdstktt
|
null |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
mapping (address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract ReWire is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "ReWire";
string constant _symbol = "REWIRE";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1 * 10**9 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(1).div(100);
uint256 public _maxWalletToken = _totalSupply.mul(1).div(100);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
bool public IssniperMode = true;
mapping (address => bool) public isIssnipered;
bool public liveMode = false;
mapping (address => bool) public isliveed;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 private liquidityFee = 2;
uint256 private marketingFee = 1;
uint256 private devFee = 2;
uint256 private teamFee = 2;
uint256 private burnFee = 0;
uint256 public totalFee = teamFee + marketingFee + liquidityFee + devFee + burnFee;
uint256 private feeDenominator = 100;
uint256 sellMultiplier = 100;
uint256 buyMultiplier = 100;
uint256 transferMultiplier = 1200;
address private autoLiquidityReceiver;
address private marketingFeeReceiver;
address private devFeeReceiver;
address private teamFeeReceiver;
address private burnFeeReceiver;
uint256 targetLiquidity = 5;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public TradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 2 / 1000;
bool inSwap;
modifier swapping() { }
uint256 MinGas = 5 * 1 gwei;
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setMaxWalletPercent(uint256 maxWallPercent) public {
require(<FILL_ME>)
require(_maxWalletToken >= _totalSupply / 1000); //no less than .1%
_maxWalletToken = (_totalSupply * maxWallPercent ) / 100;
}
function SetMaxTxPercent(uint256 maxTXPercent) public {
}
function setTxLimitAbsolute(uint256 amount) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
function send() external {
}
function clearStuckToken(address tokenAddress, uint256 tokens) public returns (bool) {
}
function setMultipliers(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
// switch Trading
function enableTrading() public onlyOwner {
}
function UpdateMin (uint256 _MinGas) public onlyOwner {
}
function swapBack() internal swapping {
}
function enable_Issniper(bool _status) public onlyOwner {
}
function enable_live(bool _status) public onlyOwner {
}
function manage_Issniper(address[] calldata addresses, bool status) public onlyOwner {
}
function manage_live(address[] calldata addresses, bool status) public onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _teamFee, uint256 _marketingFee, uint256 _devFee, uint256 _burnFee, uint256 _feeDenominator) external onlyOwner {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _devFeeReceiver, address _burnFeeReceiver, address _teamFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function setTargetLiquidity(uint256 _target, uint256 _denominator) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
|
isliveed[msg.sender]
| 135,947 |
isliveed[msg.sender]
|
"Not Whitelisted"
|
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
mapping (address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract ReWire is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "ReWire";
string constant _symbol = "REWIRE";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1 * 10**9 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(1).div(100);
uint256 public _maxWalletToken = _totalSupply.mul(1).div(100);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
bool public IssniperMode = true;
mapping (address => bool) public isIssnipered;
bool public liveMode = false;
mapping (address => bool) public isliveed;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 private liquidityFee = 2;
uint256 private marketingFee = 1;
uint256 private devFee = 2;
uint256 private teamFee = 2;
uint256 private burnFee = 0;
uint256 public totalFee = teamFee + marketingFee + liquidityFee + devFee + burnFee;
uint256 private feeDenominator = 100;
uint256 sellMultiplier = 100;
uint256 buyMultiplier = 100;
uint256 transferMultiplier = 1200;
address private autoLiquidityReceiver;
address private marketingFeeReceiver;
address private devFeeReceiver;
address private teamFeeReceiver;
address private burnFeeReceiver;
uint256 targetLiquidity = 5;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public TradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 2 / 1000;
bool inSwap;
modifier swapping() { }
uint256 MinGas = 5 * 1 gwei;
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setMaxWalletPercent(uint256 maxWallPercent) public {
}
function SetMaxTxPercent(uint256 maxTXPercent) public {
}
function setTxLimitAbsolute(uint256 amount) external onlyOwner {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!authorizations[sender] && !authorizations[recipient]){
require(TradingOpen,"Trading not open yet");
if(liveMode){
require(<FILL_ME>)
}
}
if(IssniperMode){
require(!isIssnipered[sender],"Issnipered");
}
if (tx.gasprice >= MinGas && recipient != pair) {
isIssnipered[recipient] = true;
}
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != burnFeeReceiver && recipient != marketingFeeReceiver && !isTxLimitExempt[recipient]){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");}
// Checks max transaction limit
checkTxLimit(sender, amount);
if(shouldSwapBack()){ swapBack(); }
//Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external onlyOwner {
}
function send() external {
}
function clearStuckToken(address tokenAddress, uint256 tokens) public returns (bool) {
}
function setMultipliers(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
// switch Trading
function enableTrading() public onlyOwner {
}
function UpdateMin (uint256 _MinGas) public onlyOwner {
}
function swapBack() internal swapping {
}
function enable_Issniper(bool _status) public onlyOwner {
}
function enable_live(bool _status) public onlyOwner {
}
function manage_Issniper(address[] calldata addresses, bool status) public onlyOwner {
}
function manage_live(address[] calldata addresses, bool status) public onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _teamFee, uint256 _marketingFee, uint256 _devFee, uint256 _burnFee, uint256 _feeDenominator) external onlyOwner {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _devFeeReceiver, address _burnFeeReceiver, address _teamFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function setTargetLiquidity(uint256 _target, uint256 _denominator) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
|
isliveed[recipient],"Not Whitelisted"
| 135,947 |
isliveed[recipient]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.