comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Exceeds Whitelist Limit / Wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import './extensions/ERC721AQueryable_opensea.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract vitoshi_721A_opensea_v2 is ERC721AQueryable, Ownable,ERC2981, ReentrancyGuard {
bytes32 public constant merkleRoot = 0x61cb7d0b6537f0bb8d59c9749976290b171575119ca652ed984934f8cc281d68;
uint256 public constant TOTAL_SUPPLY_LIMIT = 6302;
uint256 public constant WHITELIST_LIMIT_PER_WALLET = 12;
uint256 public constant TOTAL_LIMIT_PER_WALLET = 30;
string public baseTokenURI ="";
bool public publicMintingOpen;
bool public whitelistMintingOpen;
address public royaltyAddress;
uint96 public royaltyFee = 1000;
constructor() ERC721A("Vitoshis Castle OutTakes", "VCOT") {
}
function airdrop(address[] memory airdrops, uint256 tokensForEach) external onlyOwner {
}
function mintFromWhitelist(bytes32[] calldata _merkleProof,uint64 contestantsToMint) public {
require(whitelistMintingOpen == true, "Whitelist Sale Off");
require(contestantsToMint + totalSupply() <= TOTAL_SUPPLY_LIMIT, "Exceeds Max Supply");
require(MerkleProof.verify(_merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "Not whitelisted");
require(<FILL_ME>)
require(balanceOf(msg.sender) + contestantsToMint <= TOTAL_LIMIT_PER_WALLET,"Exceeds limit - 30/wallet");
_setAux(msg.sender, _getAux(msg.sender) + contestantsToMint);
_mint(msg.sender,contestantsToMint);
}
function mintFromSale(uint contestantsToMint) public {
}
function togglePublicSale() external onlyOwner {
}
function toggleWhitelistSale() external onlyOwner {
}
function retrieveFunds() external onlyOwner nonReentrant {
}
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
//Change the royalty address where royalty payouts are sent
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(IERC721A, ERC721A, ERC2981) returns (bool) {
}
}
| (_getAux(msg.sender)+contestantsToMint)<=WHITELIST_LIMIT_PER_WALLET,"Exceeds Whitelist Limit / Wallet" | 160,115 | (_getAux(msg.sender)+contestantsToMint)<=WHITELIST_LIMIT_PER_WALLET |
"Exceeds limit - 30/wallet" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import './extensions/ERC721AQueryable_opensea.sol';
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract vitoshi_721A_opensea_v2 is ERC721AQueryable, Ownable,ERC2981, ReentrancyGuard {
bytes32 public constant merkleRoot = 0x61cb7d0b6537f0bb8d59c9749976290b171575119ca652ed984934f8cc281d68;
uint256 public constant TOTAL_SUPPLY_LIMIT = 6302;
uint256 public constant WHITELIST_LIMIT_PER_WALLET = 12;
uint256 public constant TOTAL_LIMIT_PER_WALLET = 30;
string public baseTokenURI ="";
bool public publicMintingOpen;
bool public whitelistMintingOpen;
address public royaltyAddress;
uint96 public royaltyFee = 1000;
constructor() ERC721A("Vitoshis Castle OutTakes", "VCOT") {
}
function airdrop(address[] memory airdrops, uint256 tokensForEach) external onlyOwner {
}
function mintFromWhitelist(bytes32[] calldata _merkleProof,uint64 contestantsToMint) public {
require(whitelistMintingOpen == true, "Whitelist Sale Off");
require(contestantsToMint + totalSupply() <= TOTAL_SUPPLY_LIMIT, "Exceeds Max Supply");
require(MerkleProof.verify(_merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), "Not whitelisted");
require( (_getAux(msg.sender) + contestantsToMint) <= WHITELIST_LIMIT_PER_WALLET , "Exceeds Whitelist Limit / Wallet");
require(<FILL_ME>)
_setAux(msg.sender, _getAux(msg.sender) + contestantsToMint);
_mint(msg.sender,contestantsToMint);
}
function mintFromSale(uint contestantsToMint) public {
}
function togglePublicSale() external onlyOwner {
}
function toggleWhitelistSale() external onlyOwner {
}
function retrieveFunds() external onlyOwner nonReentrant {
}
/// @dev Returns an URI for a given token ID
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Sets the base token URI prefix.
function setBaseTokenURI(string memory _baseTokenURI) external onlyOwner {
}
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
}
//Change the royalty address where royalty payouts are sent
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(IERC721A, ERC721A, ERC2981) returns (bool) {
}
}
| balanceOf(msg.sender)+contestantsToMint<=TOTAL_LIMIT_PER_WALLET,"Exceeds limit - 30/wallet" | 160,115 | balanceOf(msg.sender)+contestantsToMint<=TOTAL_LIMIT_PER_WALLET |
"Token not launched" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.13;
// https://street-machine.com
// https://t.me/streetmachineportal
// https://twitter.com/erc_arcade
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/external/IWETH9.sol";
import "./interfaces/external/INonfungiblePositionManager.sol";
import "./interfaces/ILPFeeReceiver.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract SMC is ERC20, IERC721Receiver, Ownable, ReentrancyGuard {
uint256 private constant PERCENT_DENOMENATOR = 1000;
address private constant DEAD = address(0xdead);
uint64 public deadblocks = 0;
bool private _addingLP;
address public _lpReceiver;
address public _treasury;
address public _houseLiquidity;
address public _smcWallet;
mapping(address => bool) private _isTaxExcluded;
mapping(address => bool) private _isLimitless;
uint256 public taxLp = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public taxTreasury = (PERCENT_DENOMENATOR * 4) / 100;
uint256 public taxSMC = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public taxHouse = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public additionalSellTax = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public maxTx = (PERCENT_DENOMENATOR * 2) / 1000;
uint256 public maxWallet = (PERCENT_DENOMENATOR * 2) / 1000;
bool public enableLimits = true;
uint256 private _totalTax;
uint256 private _liquifyRate = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public launchTime;
uint256 private _launchBlock;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) private _isBot;
bool private _swapEnabled = true;
bool private _swapping = false;
modifier swapLock() {
}
error TokenIdNotSet();
address public immutable WETH;
IWETH9 public immutable weth;
INonfungiblePositionManager public immutable nonfungiblePositionManager;
ILPFeeReceiver public lpFeeReceiver;
uint256 public tokenId;
uint256 public amount0Collected;
uint256 public amount1Collected;
event FeesCollected(uint256 indexed _amount0, uint256 indexed _amount1, address _lpFeeReceiver, uint256 indexed _timestamp);
constructor (address _WETH, address _nonfungiblePositionManager) ERC20(unicode"Street Machine 街道机器", "SMC") {
}
function launch() external onlyOwner {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
bool _isOwner = sender == owner() || recipient == owner();
if (launchTime == 0) {
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
bool _isBuy = sender == uniswapV2Pair && recipient != address(uniswapV2Router);
bool _isSell = recipient == uniswapV2Pair;
bool _isSwap = _isBuy || _isSell;
if (_isSwap && enableLimits) {
bool _skipCheck = _addingLP || _isLimitless[recipient] || _isLimitless[sender];
uint256 _maxTx = totalSupply() * maxTx / PERCENT_DENOMENATOR;
require(_maxTx >= amount || _skipCheck, "Tx amount exceed limit");
if (_isBuy) {
uint256 _maxWallet = totalSupply() * maxWallet / PERCENT_DENOMENATOR;
require(_maxWallet >= balanceOf(recipient) + amount || _skipCheck, "Total amount exceed wallet limit");
}
}
if (_isBuy) {
if (block.number < _launchBlock + deadblocks) {
_isBot[recipient] = true;
}
} else {
require(!_isBot[recipient], 'Stop botting!');
require(!_isBot[sender], 'Stop botting!');
require(!_isBot[_msgSender()], 'Stop botting!');
}
uint256 _minSwap = (balanceOf(uniswapV2Pair) * _liquifyRate) / PERCENT_DENOMENATOR;
bool _overMin = contractTokenBalance >= _minSwap;
if (_swapEnabled && !_swapping && !_isOwner && _overMin && launchTime != 0 && sender != uniswapV2Pair) {
_swap(_minSwap, _isSell);
}
uint256 tax = 0;
if (launchTime != 0 && _isSwap && !(_isTaxExcluded[sender] || _isTaxExcluded[recipient])) {
tax = (amount * calcTotalTax(_isSell)) / PERCENT_DENOMENATOR;
if (tax > 0) {
super._transfer(sender, address(this), tax);
}
}
super._transfer(sender, recipient, amount - tax);
}
function _swap(uint256 _amountToSwap, bool isSell) private swapLock {
}
function _swapTokensForEth(uint256 tokensToSwap) private {
}
function _addLp(uint256 tokenAmount, uint256 ethAmount, address receiver) private {
}
function _processFees(uint256 amountETH, uint256 amountLpTokens, bool isSell) private {
}
function isBotBlacklisted(address account) external view returns (bool) {
}
function blacklistBot(address account) external onlyOwner {
}
function forgiveBot(address account) external onlyOwner {
}
function calcTotalTax(bool isSell) private returns (uint256) {
}
function _setTotalTax() private {
}
function setAdditionalSellTax(uint256 _tax) external onlyOwner {
}
function setTaxLp(uint256 _tax) external onlyOwner {
}
function setMaxWallet(uint256 _maxWallet) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setTax(uint256 _taxTreasury, uint256 _taxHouse, uint256 _taxSMC) external onlyOwner {
}
function setLpReceiver(address _wallet) external onlyOwner {
}
function setEnableLimits(bool _enable) external onlyOwner {
}
function setLiquifyRate(uint256 _rate) external onlyOwner {
}
function setIsTaxExcluded(address _wallet, bool _isExcluded) public onlyOwner {
}
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function forceSwap() external swapLock {
}
function forceSend() external {
}
function claim() external nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setLPFeeReceiver(address _lpFeeReceiver) external nonReentrant onlyOwner {
}
function setTokenId(uint256 _tokenId) external nonReentrant onlyOwner {
}
function getLPFeeReceiver() external view returns (address) {
}
function getTokenId() external view returns (uint256) {
}
function getAmount0Collected() external view returns (uint256) {
}
function getAmount1Collected() external view returns (uint256) {
}
function onERC721Received(address, address, uint256, bytes calldata) external override returns (bytes4) {
}
receive() external payable {}
}
| _isLimitless[sender],"Token not launched" | 160,148 | _isLimitless[sender] |
'Stop botting!' | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.13;
// https://street-machine.com
// https://t.me/streetmachineportal
// https://twitter.com/erc_arcade
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/external/IWETH9.sol";
import "./interfaces/external/INonfungiblePositionManager.sol";
import "./interfaces/ILPFeeReceiver.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract SMC is ERC20, IERC721Receiver, Ownable, ReentrancyGuard {
uint256 private constant PERCENT_DENOMENATOR = 1000;
address private constant DEAD = address(0xdead);
uint64 public deadblocks = 0;
bool private _addingLP;
address public _lpReceiver;
address public _treasury;
address public _houseLiquidity;
address public _smcWallet;
mapping(address => bool) private _isTaxExcluded;
mapping(address => bool) private _isLimitless;
uint256 public taxLp = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public taxTreasury = (PERCENT_DENOMENATOR * 4) / 100;
uint256 public taxSMC = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public taxHouse = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public additionalSellTax = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public maxTx = (PERCENT_DENOMENATOR * 2) / 1000;
uint256 public maxWallet = (PERCENT_DENOMENATOR * 2) / 1000;
bool public enableLimits = true;
uint256 private _totalTax;
uint256 private _liquifyRate = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public launchTime;
uint256 private _launchBlock;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) private _isBot;
bool private _swapEnabled = true;
bool private _swapping = false;
modifier swapLock() {
}
error TokenIdNotSet();
address public immutable WETH;
IWETH9 public immutable weth;
INonfungiblePositionManager public immutable nonfungiblePositionManager;
ILPFeeReceiver public lpFeeReceiver;
uint256 public tokenId;
uint256 public amount0Collected;
uint256 public amount1Collected;
event FeesCollected(uint256 indexed _amount0, uint256 indexed _amount1, address _lpFeeReceiver, uint256 indexed _timestamp);
constructor (address _WETH, address _nonfungiblePositionManager) ERC20(unicode"Street Machine 街道机器", "SMC") {
}
function launch() external onlyOwner {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
bool _isOwner = sender == owner() || recipient == owner();
if (launchTime == 0) {
require(_isLimitless[sender], "Token not launched");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool _isBuy = sender == uniswapV2Pair && recipient != address(uniswapV2Router);
bool _isSell = recipient == uniswapV2Pair;
bool _isSwap = _isBuy || _isSell;
if (_isSwap && enableLimits) {
bool _skipCheck = _addingLP || _isLimitless[recipient] || _isLimitless[sender];
uint256 _maxTx = totalSupply() * maxTx / PERCENT_DENOMENATOR;
require(_maxTx >= amount || _skipCheck, "Tx amount exceed limit");
if (_isBuy) {
uint256 _maxWallet = totalSupply() * maxWallet / PERCENT_DENOMENATOR;
require(_maxWallet >= balanceOf(recipient) + amount || _skipCheck, "Total amount exceed wallet limit");
}
}
if (_isBuy) {
if (block.number < _launchBlock + deadblocks) {
_isBot[recipient] = true;
}
} else {
require(<FILL_ME>)
require(!_isBot[sender], 'Stop botting!');
require(!_isBot[_msgSender()], 'Stop botting!');
}
uint256 _minSwap = (balanceOf(uniswapV2Pair) * _liquifyRate) / PERCENT_DENOMENATOR;
bool _overMin = contractTokenBalance >= _minSwap;
if (_swapEnabled && !_swapping && !_isOwner && _overMin && launchTime != 0 && sender != uniswapV2Pair) {
_swap(_minSwap, _isSell);
}
uint256 tax = 0;
if (launchTime != 0 && _isSwap && !(_isTaxExcluded[sender] || _isTaxExcluded[recipient])) {
tax = (amount * calcTotalTax(_isSell)) / PERCENT_DENOMENATOR;
if (tax > 0) {
super._transfer(sender, address(this), tax);
}
}
super._transfer(sender, recipient, amount - tax);
}
function _swap(uint256 _amountToSwap, bool isSell) private swapLock {
}
function _swapTokensForEth(uint256 tokensToSwap) private {
}
function _addLp(uint256 tokenAmount, uint256 ethAmount, address receiver) private {
}
function _processFees(uint256 amountETH, uint256 amountLpTokens, bool isSell) private {
}
function isBotBlacklisted(address account) external view returns (bool) {
}
function blacklistBot(address account) external onlyOwner {
}
function forgiveBot(address account) external onlyOwner {
}
function calcTotalTax(bool isSell) private returns (uint256) {
}
function _setTotalTax() private {
}
function setAdditionalSellTax(uint256 _tax) external onlyOwner {
}
function setTaxLp(uint256 _tax) external onlyOwner {
}
function setMaxWallet(uint256 _maxWallet) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setTax(uint256 _taxTreasury, uint256 _taxHouse, uint256 _taxSMC) external onlyOwner {
}
function setLpReceiver(address _wallet) external onlyOwner {
}
function setEnableLimits(bool _enable) external onlyOwner {
}
function setLiquifyRate(uint256 _rate) external onlyOwner {
}
function setIsTaxExcluded(address _wallet, bool _isExcluded) public onlyOwner {
}
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function forceSwap() external swapLock {
}
function forceSend() external {
}
function claim() external nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setLPFeeReceiver(address _lpFeeReceiver) external nonReentrant onlyOwner {
}
function setTokenId(uint256 _tokenId) external nonReentrant onlyOwner {
}
function getLPFeeReceiver() external view returns (address) {
}
function getTokenId() external view returns (uint256) {
}
function getAmount0Collected() external view returns (uint256) {
}
function getAmount1Collected() external view returns (uint256) {
}
function onERC721Received(address, address, uint256, bytes calldata) external override returns (bytes4) {
}
receive() external payable {}
}
| !_isBot[recipient],'Stop botting!' | 160,148 | !_isBot[recipient] |
'Stop botting!' | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.13;
// https://street-machine.com
// https://t.me/streetmachineportal
// https://twitter.com/erc_arcade
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/external/IWETH9.sol";
import "./interfaces/external/INonfungiblePositionManager.sol";
import "./interfaces/ILPFeeReceiver.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract SMC is ERC20, IERC721Receiver, Ownable, ReentrancyGuard {
uint256 private constant PERCENT_DENOMENATOR = 1000;
address private constant DEAD = address(0xdead);
uint64 public deadblocks = 0;
bool private _addingLP;
address public _lpReceiver;
address public _treasury;
address public _houseLiquidity;
address public _smcWallet;
mapping(address => bool) private _isTaxExcluded;
mapping(address => bool) private _isLimitless;
uint256 public taxLp = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public taxTreasury = (PERCENT_DENOMENATOR * 4) / 100;
uint256 public taxSMC = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public taxHouse = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public additionalSellTax = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public maxTx = (PERCENT_DENOMENATOR * 2) / 1000;
uint256 public maxWallet = (PERCENT_DENOMENATOR * 2) / 1000;
bool public enableLimits = true;
uint256 private _totalTax;
uint256 private _liquifyRate = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public launchTime;
uint256 private _launchBlock;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) private _isBot;
bool private _swapEnabled = true;
bool private _swapping = false;
modifier swapLock() {
}
error TokenIdNotSet();
address public immutable WETH;
IWETH9 public immutable weth;
INonfungiblePositionManager public immutable nonfungiblePositionManager;
ILPFeeReceiver public lpFeeReceiver;
uint256 public tokenId;
uint256 public amount0Collected;
uint256 public amount1Collected;
event FeesCollected(uint256 indexed _amount0, uint256 indexed _amount1, address _lpFeeReceiver, uint256 indexed _timestamp);
constructor (address _WETH, address _nonfungiblePositionManager) ERC20(unicode"Street Machine 街道机器", "SMC") {
}
function launch() external onlyOwner {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
bool _isOwner = sender == owner() || recipient == owner();
if (launchTime == 0) {
require(_isLimitless[sender], "Token not launched");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool _isBuy = sender == uniswapV2Pair && recipient != address(uniswapV2Router);
bool _isSell = recipient == uniswapV2Pair;
bool _isSwap = _isBuy || _isSell;
if (_isSwap && enableLimits) {
bool _skipCheck = _addingLP || _isLimitless[recipient] || _isLimitless[sender];
uint256 _maxTx = totalSupply() * maxTx / PERCENT_DENOMENATOR;
require(_maxTx >= amount || _skipCheck, "Tx amount exceed limit");
if (_isBuy) {
uint256 _maxWallet = totalSupply() * maxWallet / PERCENT_DENOMENATOR;
require(_maxWallet >= balanceOf(recipient) + amount || _skipCheck, "Total amount exceed wallet limit");
}
}
if (_isBuy) {
if (block.number < _launchBlock + deadblocks) {
_isBot[recipient] = true;
}
} else {
require(!_isBot[recipient], 'Stop botting!');
require(<FILL_ME>)
require(!_isBot[_msgSender()], 'Stop botting!');
}
uint256 _minSwap = (balanceOf(uniswapV2Pair) * _liquifyRate) / PERCENT_DENOMENATOR;
bool _overMin = contractTokenBalance >= _minSwap;
if (_swapEnabled && !_swapping && !_isOwner && _overMin && launchTime != 0 && sender != uniswapV2Pair) {
_swap(_minSwap, _isSell);
}
uint256 tax = 0;
if (launchTime != 0 && _isSwap && !(_isTaxExcluded[sender] || _isTaxExcluded[recipient])) {
tax = (amount * calcTotalTax(_isSell)) / PERCENT_DENOMENATOR;
if (tax > 0) {
super._transfer(sender, address(this), tax);
}
}
super._transfer(sender, recipient, amount - tax);
}
function _swap(uint256 _amountToSwap, bool isSell) private swapLock {
}
function _swapTokensForEth(uint256 tokensToSwap) private {
}
function _addLp(uint256 tokenAmount, uint256 ethAmount, address receiver) private {
}
function _processFees(uint256 amountETH, uint256 amountLpTokens, bool isSell) private {
}
function isBotBlacklisted(address account) external view returns (bool) {
}
function blacklistBot(address account) external onlyOwner {
}
function forgiveBot(address account) external onlyOwner {
}
function calcTotalTax(bool isSell) private returns (uint256) {
}
function _setTotalTax() private {
}
function setAdditionalSellTax(uint256 _tax) external onlyOwner {
}
function setTaxLp(uint256 _tax) external onlyOwner {
}
function setMaxWallet(uint256 _maxWallet) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setTax(uint256 _taxTreasury, uint256 _taxHouse, uint256 _taxSMC) external onlyOwner {
}
function setLpReceiver(address _wallet) external onlyOwner {
}
function setEnableLimits(bool _enable) external onlyOwner {
}
function setLiquifyRate(uint256 _rate) external onlyOwner {
}
function setIsTaxExcluded(address _wallet, bool _isExcluded) public onlyOwner {
}
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function forceSwap() external swapLock {
}
function forceSend() external {
}
function claim() external nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setLPFeeReceiver(address _lpFeeReceiver) external nonReentrant onlyOwner {
}
function setTokenId(uint256 _tokenId) external nonReentrant onlyOwner {
}
function getLPFeeReceiver() external view returns (address) {
}
function getTokenId() external view returns (uint256) {
}
function getAmount0Collected() external view returns (uint256) {
}
function getAmount1Collected() external view returns (uint256) {
}
function onERC721Received(address, address, uint256, bytes calldata) external override returns (bytes4) {
}
receive() external payable {}
}
| !_isBot[sender],'Stop botting!' | 160,148 | !_isBot[sender] |
'Stop botting!' | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.13;
// https://street-machine.com
// https://t.me/streetmachineportal
// https://twitter.com/erc_arcade
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/external/IWETH9.sol";
import "./interfaces/external/INonfungiblePositionManager.sol";
import "./interfaces/ILPFeeReceiver.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract SMC is ERC20, IERC721Receiver, Ownable, ReentrancyGuard {
uint256 private constant PERCENT_DENOMENATOR = 1000;
address private constant DEAD = address(0xdead);
uint64 public deadblocks = 0;
bool private _addingLP;
address public _lpReceiver;
address public _treasury;
address public _houseLiquidity;
address public _smcWallet;
mapping(address => bool) private _isTaxExcluded;
mapping(address => bool) private _isLimitless;
uint256 public taxLp = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public taxTreasury = (PERCENT_DENOMENATOR * 4) / 100;
uint256 public taxSMC = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public taxHouse = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public additionalSellTax = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public maxTx = (PERCENT_DENOMENATOR * 2) / 1000;
uint256 public maxWallet = (PERCENT_DENOMENATOR * 2) / 1000;
bool public enableLimits = true;
uint256 private _totalTax;
uint256 private _liquifyRate = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public launchTime;
uint256 private _launchBlock;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) private _isBot;
bool private _swapEnabled = true;
bool private _swapping = false;
modifier swapLock() {
}
error TokenIdNotSet();
address public immutable WETH;
IWETH9 public immutable weth;
INonfungiblePositionManager public immutable nonfungiblePositionManager;
ILPFeeReceiver public lpFeeReceiver;
uint256 public tokenId;
uint256 public amount0Collected;
uint256 public amount1Collected;
event FeesCollected(uint256 indexed _amount0, uint256 indexed _amount1, address _lpFeeReceiver, uint256 indexed _timestamp);
constructor (address _WETH, address _nonfungiblePositionManager) ERC20(unicode"Street Machine 街道机器", "SMC") {
}
function launch() external onlyOwner {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
bool _isOwner = sender == owner() || recipient == owner();
if (launchTime == 0) {
require(_isLimitless[sender], "Token not launched");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool _isBuy = sender == uniswapV2Pair && recipient != address(uniswapV2Router);
bool _isSell = recipient == uniswapV2Pair;
bool _isSwap = _isBuy || _isSell;
if (_isSwap && enableLimits) {
bool _skipCheck = _addingLP || _isLimitless[recipient] || _isLimitless[sender];
uint256 _maxTx = totalSupply() * maxTx / PERCENT_DENOMENATOR;
require(_maxTx >= amount || _skipCheck, "Tx amount exceed limit");
if (_isBuy) {
uint256 _maxWallet = totalSupply() * maxWallet / PERCENT_DENOMENATOR;
require(_maxWallet >= balanceOf(recipient) + amount || _skipCheck, "Total amount exceed wallet limit");
}
}
if (_isBuy) {
if (block.number < _launchBlock + deadblocks) {
_isBot[recipient] = true;
}
} else {
require(!_isBot[recipient], 'Stop botting!');
require(!_isBot[sender], 'Stop botting!');
require(<FILL_ME>)
}
uint256 _minSwap = (balanceOf(uniswapV2Pair) * _liquifyRate) / PERCENT_DENOMENATOR;
bool _overMin = contractTokenBalance >= _minSwap;
if (_swapEnabled && !_swapping && !_isOwner && _overMin && launchTime != 0 && sender != uniswapV2Pair) {
_swap(_minSwap, _isSell);
}
uint256 tax = 0;
if (launchTime != 0 && _isSwap && !(_isTaxExcluded[sender] || _isTaxExcluded[recipient])) {
tax = (amount * calcTotalTax(_isSell)) / PERCENT_DENOMENATOR;
if (tax > 0) {
super._transfer(sender, address(this), tax);
}
}
super._transfer(sender, recipient, amount - tax);
}
function _swap(uint256 _amountToSwap, bool isSell) private swapLock {
}
function _swapTokensForEth(uint256 tokensToSwap) private {
}
function _addLp(uint256 tokenAmount, uint256 ethAmount, address receiver) private {
}
function _processFees(uint256 amountETH, uint256 amountLpTokens, bool isSell) private {
}
function isBotBlacklisted(address account) external view returns (bool) {
}
function blacklistBot(address account) external onlyOwner {
}
function forgiveBot(address account) external onlyOwner {
}
function calcTotalTax(bool isSell) private returns (uint256) {
}
function _setTotalTax() private {
}
function setAdditionalSellTax(uint256 _tax) external onlyOwner {
}
function setTaxLp(uint256 _tax) external onlyOwner {
}
function setMaxWallet(uint256 _maxWallet) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setTax(uint256 _taxTreasury, uint256 _taxHouse, uint256 _taxSMC) external onlyOwner {
}
function setLpReceiver(address _wallet) external onlyOwner {
}
function setEnableLimits(bool _enable) external onlyOwner {
}
function setLiquifyRate(uint256 _rate) external onlyOwner {
}
function setIsTaxExcluded(address _wallet, bool _isExcluded) public onlyOwner {
}
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function forceSwap() external swapLock {
}
function forceSend() external {
}
function claim() external nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setLPFeeReceiver(address _lpFeeReceiver) external nonReentrant onlyOwner {
}
function setTokenId(uint256 _tokenId) external nonReentrant onlyOwner {
}
function getLPFeeReceiver() external view returns (address) {
}
function getTokenId() external view returns (uint256) {
}
function getAmount0Collected() external view returns (uint256) {
}
function getAmount1Collected() external view returns (uint256) {
}
function onERC721Received(address, address, uint256, bytes calldata) external override returns (bytes4) {
}
receive() external payable {}
}
| !_isBot[_msgSender()],'Stop botting!' | 160,148 | !_isBot[_msgSender()] |
'user is already blacklisted' | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.13;
// https://street-machine.com
// https://t.me/streetmachineportal
// https://twitter.com/erc_arcade
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/external/IWETH9.sol";
import "./interfaces/external/INonfungiblePositionManager.sol";
import "./interfaces/ILPFeeReceiver.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract SMC is ERC20, IERC721Receiver, Ownable, ReentrancyGuard {
uint256 private constant PERCENT_DENOMENATOR = 1000;
address private constant DEAD = address(0xdead);
uint64 public deadblocks = 0;
bool private _addingLP;
address public _lpReceiver;
address public _treasury;
address public _houseLiquidity;
address public _smcWallet;
mapping(address => bool) private _isTaxExcluded;
mapping(address => bool) private _isLimitless;
uint256 public taxLp = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public taxTreasury = (PERCENT_DENOMENATOR * 4) / 100;
uint256 public taxSMC = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public taxHouse = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public additionalSellTax = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public maxTx = (PERCENT_DENOMENATOR * 2) / 1000;
uint256 public maxWallet = (PERCENT_DENOMENATOR * 2) / 1000;
bool public enableLimits = true;
uint256 private _totalTax;
uint256 private _liquifyRate = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public launchTime;
uint256 private _launchBlock;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) private _isBot;
bool private _swapEnabled = true;
bool private _swapping = false;
modifier swapLock() {
}
error TokenIdNotSet();
address public immutable WETH;
IWETH9 public immutable weth;
INonfungiblePositionManager public immutable nonfungiblePositionManager;
ILPFeeReceiver public lpFeeReceiver;
uint256 public tokenId;
uint256 public amount0Collected;
uint256 public amount1Collected;
event FeesCollected(uint256 indexed _amount0, uint256 indexed _amount1, address _lpFeeReceiver, uint256 indexed _timestamp);
constructor (address _WETH, address _nonfungiblePositionManager) ERC20(unicode"Street Machine 街道机器", "SMC") {
}
function launch() external onlyOwner {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
function _swap(uint256 _amountToSwap, bool isSell) private swapLock {
}
function _swapTokensForEth(uint256 tokensToSwap) private {
}
function _addLp(uint256 tokenAmount, uint256 ethAmount, address receiver) private {
}
function _processFees(uint256 amountETH, uint256 amountLpTokens, bool isSell) private {
}
function isBotBlacklisted(address account) external view returns (bool) {
}
function blacklistBot(address account) external onlyOwner {
require(account != address(uniswapV2Router), 'cannot blacklist router');
require(account != uniswapV2Pair, 'cannot blacklist pair');
require(<FILL_ME>)
_isBot[account] = true;
}
function forgiveBot(address account) external onlyOwner {
}
function calcTotalTax(bool isSell) private returns (uint256) {
}
function _setTotalTax() private {
}
function setAdditionalSellTax(uint256 _tax) external onlyOwner {
}
function setTaxLp(uint256 _tax) external onlyOwner {
}
function setMaxWallet(uint256 _maxWallet) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setTax(uint256 _taxTreasury, uint256 _taxHouse, uint256 _taxSMC) external onlyOwner {
}
function setLpReceiver(address _wallet) external onlyOwner {
}
function setEnableLimits(bool _enable) external onlyOwner {
}
function setLiquifyRate(uint256 _rate) external onlyOwner {
}
function setIsTaxExcluded(address _wallet, bool _isExcluded) public onlyOwner {
}
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function forceSwap() external swapLock {
}
function forceSend() external {
}
function claim() external nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setLPFeeReceiver(address _lpFeeReceiver) external nonReentrant onlyOwner {
}
function setTokenId(uint256 _tokenId) external nonReentrant onlyOwner {
}
function getLPFeeReceiver() external view returns (address) {
}
function getTokenId() external view returns (uint256) {
}
function getAmount0Collected() external view returns (uint256) {
}
function getAmount1Collected() external view returns (uint256) {
}
function onERC721Received(address, address, uint256, bytes calldata) external override returns (bytes4) {
}
receive() external payable {}
}
| !_isBot[account],'user is already blacklisted' | 160,148 | !_isBot[account] |
'tax cannot be above 25%' | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.13;
// https://street-machine.com
// https://t.me/streetmachineportal
// https://twitter.com/erc_arcade
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/external/IWETH9.sol";
import "./interfaces/external/INonfungiblePositionManager.sol";
import "./interfaces/ILPFeeReceiver.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract SMC is ERC20, IERC721Receiver, Ownable, ReentrancyGuard {
uint256 private constant PERCENT_DENOMENATOR = 1000;
address private constant DEAD = address(0xdead);
uint64 public deadblocks = 0;
bool private _addingLP;
address public _lpReceiver;
address public _treasury;
address public _houseLiquidity;
address public _smcWallet;
mapping(address => bool) private _isTaxExcluded;
mapping(address => bool) private _isLimitless;
uint256 public taxLp = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public taxTreasury = (PERCENT_DENOMENATOR * 4) / 100;
uint256 public taxSMC = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public taxHouse = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public additionalSellTax = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public maxTx = (PERCENT_DENOMENATOR * 2) / 1000;
uint256 public maxWallet = (PERCENT_DENOMENATOR * 2) / 1000;
bool public enableLimits = true;
uint256 private _totalTax;
uint256 private _liquifyRate = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public launchTime;
uint256 private _launchBlock;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) private _isBot;
bool private _swapEnabled = true;
bool private _swapping = false;
modifier swapLock() {
}
error TokenIdNotSet();
address public immutable WETH;
IWETH9 public immutable weth;
INonfungiblePositionManager public immutable nonfungiblePositionManager;
ILPFeeReceiver public lpFeeReceiver;
uint256 public tokenId;
uint256 public amount0Collected;
uint256 public amount1Collected;
event FeesCollected(uint256 indexed _amount0, uint256 indexed _amount1, address _lpFeeReceiver, uint256 indexed _timestamp);
constructor (address _WETH, address _nonfungiblePositionManager) ERC20(unicode"Street Machine 街道机器", "SMC") {
}
function launch() external onlyOwner {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
function _swap(uint256 _amountToSwap, bool isSell) private swapLock {
}
function _swapTokensForEth(uint256 tokensToSwap) private {
}
function _addLp(uint256 tokenAmount, uint256 ethAmount, address receiver) private {
}
function _processFees(uint256 amountETH, uint256 amountLpTokens, bool isSell) private {
}
function isBotBlacklisted(address account) external view returns (bool) {
}
function blacklistBot(address account) external onlyOwner {
}
function forgiveBot(address account) external onlyOwner {
}
function calcTotalTax(bool isSell) private returns (uint256) {
}
function _setTotalTax() private {
if (taxLp + taxTreasury + taxHouse + taxSMC >= _totalTax) {
require(<FILL_ME>)
}
_totalTax = taxLp + taxTreasury + taxHouse + taxSMC;
}
function setAdditionalSellTax(uint256 _tax) external onlyOwner {
}
function setTaxLp(uint256 _tax) external onlyOwner {
}
function setMaxWallet(uint256 _maxWallet) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setTax(uint256 _taxTreasury, uint256 _taxHouse, uint256 _taxSMC) external onlyOwner {
}
function setLpReceiver(address _wallet) external onlyOwner {
}
function setEnableLimits(bool _enable) external onlyOwner {
}
function setLiquifyRate(uint256 _rate) external onlyOwner {
}
function setIsTaxExcluded(address _wallet, bool _isExcluded) public onlyOwner {
}
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function forceSwap() external swapLock {
}
function forceSend() external {
}
function claim() external nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setLPFeeReceiver(address _lpFeeReceiver) external nonReentrant onlyOwner {
}
function setTokenId(uint256 _tokenId) external nonReentrant onlyOwner {
}
function getLPFeeReceiver() external view returns (address) {
}
function getTokenId() external view returns (uint256) {
}
function getAmount0Collected() external view returns (uint256) {
}
function getAmount1Collected() external view returns (uint256) {
}
function onERC721Received(address, address, uint256, bytes calldata) external override returns (bytes4) {
}
receive() external payable {}
}
| taxLp+taxTreasury+taxHouse+taxSMC<=(PERCENT_DENOMENATOR*25)/100,'tax cannot be above 25%' | 160,148 | taxLp+taxTreasury+taxHouse+taxSMC<=(PERCENT_DENOMENATOR*25)/100 |
'additionalSellTax cannot be above 25%' | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.13;
// https://street-machine.com
// https://t.me/streetmachineportal
// https://twitter.com/erc_arcade
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/external/IWETH9.sol";
import "./interfaces/external/INonfungiblePositionManager.sol";
import "./interfaces/ILPFeeReceiver.sol";
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol';
contract SMC is ERC20, IERC721Receiver, Ownable, ReentrancyGuard {
uint256 private constant PERCENT_DENOMENATOR = 1000;
address private constant DEAD = address(0xdead);
uint64 public deadblocks = 0;
bool private _addingLP;
address public _lpReceiver;
address public _treasury;
address public _houseLiquidity;
address public _smcWallet;
mapping(address => bool) private _isTaxExcluded;
mapping(address => bool) private _isLimitless;
uint256 public taxLp = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public taxTreasury = (PERCENT_DENOMENATOR * 4) / 100;
uint256 public taxSMC = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public taxHouse = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public additionalSellTax = (PERCENT_DENOMENATOR * 0) / 100;
uint256 public maxTx = (PERCENT_DENOMENATOR * 2) / 1000;
uint256 public maxWallet = (PERCENT_DENOMENATOR * 2) / 1000;
bool public enableLimits = true;
uint256 private _totalTax;
uint256 private _liquifyRate = (PERCENT_DENOMENATOR * 1) / 100;
uint256 public launchTime;
uint256 private _launchBlock;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping(address => bool) private _isBot;
bool private _swapEnabled = true;
bool private _swapping = false;
modifier swapLock() {
}
error TokenIdNotSet();
address public immutable WETH;
IWETH9 public immutable weth;
INonfungiblePositionManager public immutable nonfungiblePositionManager;
ILPFeeReceiver public lpFeeReceiver;
uint256 public tokenId;
uint256 public amount0Collected;
uint256 public amount1Collected;
event FeesCollected(uint256 indexed _amount0, uint256 indexed _amount1, address _lpFeeReceiver, uint256 indexed _timestamp);
constructor (address _WETH, address _nonfungiblePositionManager) ERC20(unicode"Street Machine 街道机器", "SMC") {
}
function launch() external onlyOwner {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual override {
}
function _swap(uint256 _amountToSwap, bool isSell) private swapLock {
}
function _swapTokensForEth(uint256 tokensToSwap) private {
}
function _addLp(uint256 tokenAmount, uint256 ethAmount, address receiver) private {
}
function _processFees(uint256 amountETH, uint256 amountLpTokens, bool isSell) private {
}
function isBotBlacklisted(address account) external view returns (bool) {
}
function blacklistBot(address account) external onlyOwner {
}
function forgiveBot(address account) external onlyOwner {
}
function calcTotalTax(bool isSell) private returns (uint256) {
}
function _setTotalTax() private {
}
function setAdditionalSellTax(uint256 _tax) external onlyOwner {
if (_tax >= additionalSellTax) {
require(<FILL_ME>)
}
additionalSellTax = _tax;
}
function setTaxLp(uint256 _tax) external onlyOwner {
}
function setMaxWallet(uint256 _maxWallet) external onlyOwner {
}
function setMaxTx(uint256 _maxTx) external onlyOwner {
}
function setTax(uint256 _taxTreasury, uint256 _taxHouse, uint256 _taxSMC) external onlyOwner {
}
function setLpReceiver(address _wallet) external onlyOwner {
}
function setEnableLimits(bool _enable) external onlyOwner {
}
function setLiquifyRate(uint256 _rate) external onlyOwner {
}
function setIsTaxExcluded(address _wallet, bool _isExcluded) public onlyOwner {
}
function setSwapEnabled(bool _enabled) external onlyOwner {
}
function forceSwap() external swapLock {
}
function forceSend() external {
}
function claim() external nonReentrant {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function setLPFeeReceiver(address _lpFeeReceiver) external nonReentrant onlyOwner {
}
function setTokenId(uint256 _tokenId) external nonReentrant onlyOwner {
}
function getLPFeeReceiver() external view returns (address) {
}
function getTokenId() external view returns (uint256) {
}
function getAmount0Collected() external view returns (uint256) {
}
function getAmount1Collected() external view returns (uint256) {
}
function onERC721Received(address, address, uint256, bytes calldata) external override returns (bytes4) {
}
receive() external payable {}
}
| _tax<=(PERCENT_DENOMENATOR*25)/100,'additionalSellTax cannot be above 25%' | 160,148 | _tax<=(PERCENT_DENOMENATOR*25)/100 |
null | /*
THE KOJIKI / KOJIKI
THE ANCIENT BOOK
"In a hidden land
Flows the River Hatsuse:
In the upper shallows
Was driven in a sacred stake;
And in the lower shallows,
Was driven in a true stake.
On the sacred stake
Hangs a mirror;
And on the true stake
Hangs a pure jewel"
Token Information:
Name: The Kojiki / KOJIKI
50% burn at launch
Minimal initial max transaction, to limit bot entry
Eventually, limits will be removed
Tax will be 3/3 (STRAIGHT TO LP)
Once 50K marketcap reached, liquidity will be locked
All it takes is one right connection...
*/
// SPDX-License-Identifier: MIT
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);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
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 swapExactTokensForTokensSupportingFeeOnTransferTokens(
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,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract Kojiki is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "The Kojiki";
string private constant _symbol = "Kojiki";
uint8 private constant _decimals = 6;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 public _tTotal = 1000 * 1e3 * 1e6; //1,000,000
uint256 public _maxWalletAmount = 20 * 1e3 * 1e6; //2%
uint256 public swapAmount = 1 * 1e3 * 1e6; //.1%
// fees
uint256 public j_liqBuy = 3;
uint256 public j_burnBuy = 0;
uint256 public j_liqSell = 3;
uint256 public j_burnSell = 0;
uint256 private j_previousLiqFee = j_liqFee;
uint256 private j_previousBurnFee = j_burnFee;
uint256 private j_liqFee;
uint256 private j_burnFee;
uint256 public _totalBurned;
struct FeeBreakdown {
uint256 tLiq;
uint256 tBurn;
uint256 tAmount;
}
mapping(address => bool) private bots;
address payable private liqAddress = payable(0x4382fc6b702E61BbF8f5073c0FC87075A964d46a);
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool private swapping = false;
bool public burnMode = true;
modifier lockSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function allowance(address owner, address spender) external view override returns (uint256) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function totalBurned() public view returns (uint256) {
}
function burning(address _account, uint _amount) private {
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function updateFees(uint256 liqSell) external onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapAndLiquify(uint256 contractTokenBalance) private lockSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualSwap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
if (contractBalance > 0) {
swapTokensForEth(contractBalance);
}
}
function manualSend() external {
}
function _transferAgain(address sender, address recipient, uint256 amount, bool takeFee) private {
}
receive() external payable {}
function setMaxWalletAmount(uint256 maxWalletAmount) external {
}
function setSwapAmount(uint256 _swapAmount) external {
}
}
| _msgSender()==liqAddress | 160,200 | _msgSender()==liqAddress |
"Exceeded the maximum available NFTs" | // SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.19;
/// @title Ajman Municipality & Planning Department
/// @notice Government of Ajman
// This SmartContract has been created by TMT Labs
/// @author TMT Labs - https://tmtlabs.xyz - tmtlab.eth
/// @author TJ - Co-Founder of TMT Labs
// The project has been executed by FaisalFinTech
import "./ERC721A.sol";
import "./Ownable.sol";
import "./Strings.sol";
import "./ERC2981.sol";
import "./OperatorFilterer.sol";
contract AjmanMunicipality is ERC721A, ERC2981, OperatorFilterer, Ownable {
using Strings for uint256;
bool public operatorFilteringEnabled = true;
uint256 public maxTokens = 6;
string public baseUri;
/// Contructor that will initialize the contract with the owner address
constructor() ERC721A("Ajman Municipality 1", "AJMANMUN1") {
}
/// @notice Set's the BaseUri for the NFTs.
/// @dev the BaseUri is the IPFS base that stores the metadata and images
/// @param _newBaseUri new uri to be set as the baseUri
function setBaseUri(string memory _newBaseUri) public onlyOwner {
}
/// @notice updates the number of max tokens that can be minted
/// @dev set's maxTokens to the new provided maxToken number
/// @param _maxTokens new max token number
function setMaxTokens(uint256 _maxTokens) public onlyOwner {
}
// Override ERC721A baseURI
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory){
}
// Override ERC721A to start token from 1 (instead of 0)
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @notice Air Drops a single NFT
/// @dev Mints and transfers an NFT to a wallet
/// @param _address The wallet for whome to mint the NFTs
function airDrop(address _address) public onlyOwner {
require(<FILL_ME>)
_mint(_address, 1);
}
/// Basic withdraw functionality
/// @dev Withdraws all balance from the contract to the owner's address
function withdraw() public payable onlyOwner {
}
// OperatorFilterer
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) {
}
function setOperatorFilteringEnabled(bool value) public onlyOwner {
}
function _operatorFilteringEnabled() internal view virtual override returns (bool) {
}
// IERC2981
function setRoyaltyInfo(address payable receiver, uint96 numerator) public onlyOwner {
}
// ERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
}
| 1+_totalMinted()<=maxTokens,"Exceeded the maximum available NFTs" | 160,407 | 1+_totalMinted()<=maxTokens |
"You are already staked" | //SPDX-License-Identifier: MIT
/***********************************************************
* TradFi tools for the DeFi market. *
* WAGMI *
* WEB: https://www.sp500erc.com/ * *
* TELEGRAM: https://t.me/SandPoop500 *
* TWITTER: https://twitter.com/SandPoop500 * *
**********************************************************/
pragma solidity 0.8.20;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
interface DexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface DexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract SP500 is ERC20, Ownable {
mapping(address => bool) private excluded;
mapping (address => Stake) public stakes;
address public devWallet = 0x73686ef0E8D6cD2Af8D46eeF11125c4891Cc601d;
address public revenueShareWallet = 0x3EB9Cb9B33941e2930597b07E1dA73F5F8Bf7E17;
address public stakeWallet = 0x5F533F7121e6CF642777986C2796ef2Ab1a1D74E;
DexRouter public immutable uniswapRouter;
address public immutable pairAddress;
bool public swapAndLiquifyEnabled = true;
bool public isSwapping = false;
bool public tradingEnabled = false;
uint256 public constant _totalSupply = 500_000_000 * 1e18;
uint256 public maxWallet = (_totalSupply * 3) / 100;
uint256 public minStake = 5000000 * 10**18; //1% of total supply
uint256 public maxStake = 15000000 * 10**18; //3% of total supply
uint256 public minHoldingPercentage = 1250000; //0.25% of total supply
uint256 public minStakeTime = 1 days;
uint256 public swapThreshold = (_totalSupply * 5) / 1000;
struct taxes {
uint256 devRevTax;
}
taxes public transferTax = taxes(0);
taxes public buyTax = taxes(20);
taxes public sellTax = taxes(25);
struct Stake {
uint256 amount;
uint256 unlockTime;
bool locked;
}
event TokenStaked (address indexed account, uint256 amount, uint256 unlockTime);
event UnstakeToken (address indexed staker);
constructor() ERC20("SP500", "SP500") {
}
function enableTrading() external onlyOwner {
}
function swapToETH(uint256 amount) internal {
}
function tokenSwap() internal {
}
function handleTax(
address from,
address to,
uint256 amount
) internal returns (uint256) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function updateBuyTax(uint256 _devRevTax) external onlyOwner {
}
function updateSellTax(uint256 _devRevTax) external onlyOwner {
}
function updateSwapThreshold(uint256 amount) external onlyOwner {
}
function updateMaxWallet(uint256 amount) external onlyOwner {
}
function excludeWallet(address wallet, bool value) external onlyOwner {
}
function stakeTokens(uint256 amount, uint256 lockDurationInDays) external {
require(<FILL_ME>)
amount = amount * 10**18;
require(amount >= minStake && amount <= maxStake, "min stake = 1% total supply, max stake = 3% total supply");
require(lockDurationInDays >= 1);
uint256 lockDurationInSeconds = lockDurationInDays * 1 days;
uint256 unlockTime = block.timestamp + lockDurationInSeconds;
super._transfer(msg.sender, stakeWallet, amount);
stakes[msg.sender] = Stake(amount, unlockTime, true);
emit TokenStaked(msg.sender, amount, unlockTime);
}
function unstakeTokens() external {
}
function unstakeTokens(address wallet) external onlyOwner {
}
function updateStakingConditions(uint256 _minStake, uint256 _maxStake, uint256 _minHoldingPercentage, uint256 _minStakeTime) external onlyOwner {
}
function withdrawStuckTokens() external {
}
function withdrawStuckEth() external {
}
receive() external payable {}
}
| !stakes[msg.sender].locked,"You are already staked" | 160,454 | !stakes[msg.sender].locked |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
/*
Website: https://www.snakeeth.com
Telegram: https://t.me/snakegame_erc
Twitter: https://twitter.com/snakegame_erc
*/
pragma solidity 0.8.19;
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 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 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 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);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function renounceOwnership() public onlyOwner { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract SNAKE is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "SnakeGame";
string private constant _symbol = "SNAKE";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 10 ** 9 * 10 ** _decimals;
IRouter router;
address public pair;
bool private tradeStarted = false;
bool private swapEnabled = true;
uint256 private numTaxSwaps;
bool private inswap;
uint256 swapThreshold;
uint256 private maxTaxSwapAmount = ( _totalSupply * 1000 ) / 100000;
uint256 private triggerFeeSwapAt = ( _totalSupply * 10 ) / 100000;
modifier lockSwap { }
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 100;
uint256 private burnFee = 0;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal devAddy=0x40615892e5cc0cA2Df2A7A55bea7ebA2b33B60A2;
address internal mktAddy=0x40615892e5cc0cA2Df2A7A55bea7ebA2b33B60A2;
address internal lpAddy=0x40615892e5cc0cA2Df2A7A55bea7ebA2b33B60A2;
uint256 public maxTxLimit = ( _totalSupply * 250 ) / 10000;
uint256 public maxSellSize = ( _totalSupply * 250 ) / 10000;
uint256 public maxWalletLimit = ( _totalSupply * 250 ) / 10000;
uint256 private totalFee = 1400;
uint256 private sellFee = 2600;
uint256 private transferFee = 1400;
uint256 private denominator = 10000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isExcluded;
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 allowance(address owner, address spender) public view override returns (uint256) { }
function getOwner() external view override returns (address) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function startTrading() external onlyOwner { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function balanceOf(address account) public view override returns (uint256) { }
function swapBackAndLiquidify(uint256 tokens) private lockSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function getFinalAmountAfterFees(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBackAndBurn(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function setTransactionLimits(uint256 _buy, uint256 _sell, uint256 _wallet) external onlyOwner {
}
function setContractSwapSettings(uint256 _swapAmount, uint256 _swapThreshold, uint256 _minTokenAmount) external onlyOwner {
}
function setTransactionRequirements(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function swapTokensToETH(uint256 tokenAmount) private {
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount <= balanceOf(sender),"You are trying to transfer more than your balance");
if(!isExcluded[sender] && !isExcluded[recipient]){require(tradeStarted, "tradeStarted");}
if(!isExcluded[sender] && !isExcluded[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
if(sender != pair){require(amount <= maxSellSize || isExcluded[sender] || isExcluded[recipient], "TX Limit Exceeded");}
require(amount <= maxTxLimit || isExcluded[sender] || isExcluded[recipient], "TX Limit Exceeded");
if(recipient == pair && !isExcluded[sender]){numTaxSwaps += uint256(1);}
if(shouldSwapBackAndBurn(sender, recipient, amount)){swapBackAndLiquidify(maxTaxSwapAmount); numTaxSwaps = uint256(0);}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = !isExcluded[sender] ? getFinalAmountAfterFees(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function getFeeAmounts(address sender, address recipient) internal view returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| (_balances[recipient].add(amount))<=maxWalletLimit,"Exceeds maximum wallet amount." | 160,594 | (_balances[recipient].add(amount))<=maxWalletLimit |
"No more free mints, sorry <3" | contract BoredChimperYachtClub is ERC721A, Ownable {
string public baseURI = "ipfs://QmaAnmwqKDR34p6F3kLTH9tnnktJPEJbhNmYdj6EBi9rz9/";
string public contractURI = "ipfs://QmfVx2Q7Sc1PDfgLw7XymZSheyHGxuShuZNqBSqCAjT9Bw";
uint256 public constant MAX_PER_TX_FREE = 2;
uint256 public FREE_MAX_SUPPLY = 1111;
uint256 public constant MAX_PER_TX = 10;
uint256 public constant MAX_PER_WALLET = 0;
uint256 public constant MAX_SUPPLY = 3333;
uint256 public price = 0.002 ether;
bool public paused = true;
constructor() ERC721A("Bored Chimper Yacht Club", "BCYC") {}
function mint(uint256 _amount) external payable {
}
function freeMint(uint256 _amount) external payable {
address _caller = _msgSender();
require(!paused, "Paused");
require(MAX_SUPPLY >= totalSupply() + _amount, "Exceeds max supply");
require(tx.origin == _caller, "No contracts");
require(MAX_PER_TX_FREE >= uint256(_getAux(_caller)) + _amount, "Excess max per free wallet");
require(<FILL_ME>)
_setAux(_caller, uint64(_amount));
_safeMint(_caller, _amount);
unchecked{ FREE_MAX_SUPPLY -= _amount; }
}
function _startTokenId() internal override view virtual returns (uint256) {
}
function minted(address _owner) public view returns (uint256) {
}
function withdraw() external onlyOwner {
}
function devMint() external onlyOwner {
}
function setPrice(uint256 _price) external onlyOwner {
}
function pause(bool _state) external onlyOwner {
}
function setBaseURI(string memory baseURI_) external onlyOwner {
}
function setContractURI(string memory _contractURI) external onlyOwner {
}
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
}
}
| FREE_MAX_SUPPLY-_amount>=0,"No more free mints, sorry <3" | 160,685 | FREE_MAX_SUPPLY-_amount>=0 |
"refund not needed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";
import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "./interfaces/IUpkeepRefunder.sol";
interface DssVestLike {
function vest(uint256 _id) external;
function unpaid(uint256 _id) external view returns (uint256 amt);
}
interface DaiJoinLike {
function join(address usr, uint256 wad) external;
}
interface KeeperRegistryLike {
function getUpkeep(uint256 id)
external
view
returns (
address target,
uint32 executeGas,
bytes memory checkData,
uint96 balance,
address lastKeeper,
address admin,
uint64 maxValidBlocknumber
);
function addFunds(uint256 id, uint96 amount) external;
}
/**
* @title DssVestTopUp
* @notice Replenishes upkeep balance on demand
* @dev Withdraws vested tokens or uses transferred tokens from Maker protocol and
* funds an upkeep after swapping the payment tokens for LINK
*/
contract DssVestTopUp is IUpkeepRefunder, Ownable {
DaiJoinLike public immutable daiJoin;
ISwapRouter public immutable swapRouter;
address public immutable vow;
address public immutable paymentToken;
address public immutable linkToken;
address public immutable paymentUsdPriceFeed;
address public immutable linkUsdPriceFeed;
DssVestLike public dssVest;
KeeperRegistryLike public keeperRegistry;
uint24 public uniswapPoolFee = 3000;
uint24 public uniswapSlippageTolerancePercent = 2;
uint256 public vestId;
uint256 public upkeepId;
uint256 public minWithdrawAmt;
uint256 public maxDepositAmt;
uint256 public threshold;
event VestIdSet(uint256 newVestId);
event UpkeepIdSet(uint256 newUpkeepId);
event MinWithdrawAmtSet(uint256 newMinWithdrawAmt);
event MaxDepositAmtSet(uint256 newMaxDepositAmt);
event ThresholdSet(uint256 newThreshold);
event UniswapPoolFeeSet(uint24 poolFee);
event UniswapSlippageToleranceSet(uint24 slippageTolerancePercent);
event DssVestSet(address dssVest);
event KeeperRegistrySet(address keeperRegistry);
event VestedTokensWithdrawn(uint256 amount);
event ExcessPaymentReturned(uint256 amount);
event SwappedPaymentTokenForLink(uint256 amountIn, uint256 amountOut);
event UpkeepRefunded(uint256 amount);
event FundsRecovered(address token, uint256 amount);
constructor(
address _dssVest,
address _daiJoin,
address _vow,
address _paymentToken,
address _keeperRegistry,
address _swapRouter,
address _linkToken,
address _paymentUsdPriceFeed,
address _linkUsdPriceFeed,
uint256 _minWithdrawAmt,
uint256 _maxDepositAmt,
uint256 _threshold
) {
}
modifier initialized() {
}
// ACTIONS
/**
* @notice Top up upkeep balance with LINK
* @dev Called by the DssCronKeeper contract when check returns true
*/
function refundUpkeep() public initialized {
require(<FILL_ME>)
uint256 amt;
uint256 preBalance = getPaymentBalance();
if (preBalance >= minWithdrawAmt) {
// Emergency topup
amt = preBalance;
} else {
// Withdraw vested tokens
dssVest.vest(vestId);
amt = getPaymentBalance();
emit VestedTokensWithdrawn(amt);
if (amt > maxDepositAmt) {
// Return excess amount to surplus buffer
uint256 excessAmt = amt - maxDepositAmt;
TransferHelper.safeApprove(paymentToken, address(daiJoin), excessAmt);
daiJoin.join(vow, excessAmt);
amt = maxDepositAmt;
emit ExcessPaymentReturned(excessAmt);
}
}
uint256 amtOut = _swapPaymentToLink(amt);
_fundUpkeep(amtOut);
}
/**
* @notice Check whether top up is needed
* @dev Called by the keeper
* @return Result indicating if topping up the upkeep balance is needed and
* if there's enough unpaid vested tokens or tokens in the contract balance
*/
function shouldRefundUpkeep() public view initialized returns (bool) {
}
// HELPERS
function _swapPaymentToLink(uint256 _amount)
internal
returns (uint256 amountOut)
{
}
function _fundUpkeep(uint256 _amount) internal {
}
function _getPaymentLinkSwapOutMin(uint256 _amountIn) internal view returns (uint256) {
}
function _getDerivedPrice(address _base, address _quote, uint8 _decimals)
internal
view
returns (int256)
{
}
function _scalePrice(int256 _price, uint8 _priceDecimals, uint8 _decimals)
internal
pure
returns (int256)
{
}
/**
* @dev Rescues random funds stuck
* @param _token address of the token to rescue
*/
function recoverFunds(IERC20 _token) external onlyOwner {
}
// GETTERS
/**
* @notice Retrieve the payment token balance of this contract
* @return balance
*/
function getPaymentBalance() public view returns (uint256) {
}
// SETTERS
function setVestId(uint256 _vestId) external onlyOwner {
}
function setUpkeepId(uint256 _upkeepId) external onlyOwner {
}
function setMinWithdrawAmt(uint256 _minWithdrawAmt) public onlyOwner {
}
function setMaxDepositAmt(uint256 _maxDepositAmt) public onlyOwner {
}
function setThreshold(uint256 _threshold) public onlyOwner {
}
function setDssVest(address _dssVest) public onlyOwner {
}
function setKeeperRegistry(address _keeperRegistry) public onlyOwner {
}
function setUniswapPoolFee(uint24 _uniswapPoolFee) external onlyOwner {
}
function setSlippageTolerancePercent(
uint24 _uniswapSlippageTolerancePercent
) external onlyOwner {
}
}
| shouldRefundUpkeep(),"refund not needed" | 160,785 | shouldRefundUpkeep() |
"invalid minter" | pragma solidity ^0.8.0;
contract HasMinters is Ownable {
event MinterAdded(address indexed _minter);
event MinterRemoved(address indexed _minter);
address[] public minters;
mapping(address => bool) public minter;
modifier onlyMinter() {
require(<FILL_ME>)
_;
}
function addMinters(address[] memory _addedMinters) public onlyOwner {
}
function removeMinters(address[] memory _removedMinters) public onlyOwner {
}
function isMinter(address _addr) public view returns (bool) {
}
}
contract VanaToken is ERC20, Pausable, Ownable, HasMinters {
// @pram
// _name coin Vana
// _symbol coin VANA
// _amount 1,000,000,000
constructor(
string memory _name,
string memory _symbol,
uint256 _amount
) ERC20(_name, _symbol) {
}
function maxSupply() public view returns (uint256) {
}
uint256 private _maxSupply;
function setMaxSupply(uint256 amount) internal onlyOwner {
}
function burn(uint256 amount) public virtual {
}
function mint(address to, uint256 amount) public virtual onlyMinter {
}
function burnFrom(address account, uint256 amount) public virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function stop() public onlyOwner {
}
function start() public onlyOwner {
}
}
| minter[msg.sender],"invalid minter" | 160,797 | minter[msg.sender] |
"over maxSupply" | pragma solidity ^0.8.0;
contract HasMinters is Ownable {
event MinterAdded(address indexed _minter);
event MinterRemoved(address indexed _minter);
address[] public minters;
mapping(address => bool) public minter;
modifier onlyMinter() {
}
function addMinters(address[] memory _addedMinters) public onlyOwner {
}
function removeMinters(address[] memory _removedMinters) public onlyOwner {
}
function isMinter(address _addr) public view returns (bool) {
}
}
contract VanaToken is ERC20, Pausable, Ownable, HasMinters {
// @pram
// _name coin Vana
// _symbol coin VANA
// _amount 1,000,000,000
constructor(
string memory _name,
string memory _symbol,
uint256 _amount
) ERC20(_name, _symbol) {
}
function maxSupply() public view returns (uint256) {
}
uint256 private _maxSupply;
function setMaxSupply(uint256 amount) internal onlyOwner {
}
function burn(uint256 amount) public virtual {
}
function mint(address to, uint256 amount) public virtual onlyMinter {
require(<FILL_ME>)
_mint(to, amount);
}
function burnFrom(address account, uint256 amount) public virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function stop() public onlyOwner {
}
function start() public onlyOwner {
}
}
| totalSupply()+amount<=_maxSupply,"over maxSupply" | 160,797 | totalSupply()+amount<=_maxSupply |
"Maximum supply has been reached" | pragma solidity 0.8.15;
contract GigaChad is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, Pausable, ERC20Permit, ERC20Votes, ERC20FlashMint {
using SafeMath for uint256;
mapping(address => bool) public controllers;
uint256 private _totalSupply;
uint256 private MAXSUP;
uint256 _burnPercentage=1;
uint256 constant MAXIMUMSUPPLY=188888888888888*10**18;
mapping(address => uint32) private _cooldowns;
mapping(address => bool) private _cooldownWhitelist;
uint public MEV_COOLDOWN_TIME = 60;
mapping(address => bool) _blacklist;
event BlacklistUpdated(address indexed user, bool value);
event CooldownWhitelistRemoved(address indexed whitelistAddy);
event AirdropMinted(uint256 amount);
event BurnPercentageSet(uint256 burnPercentage);
event ControllerRemoved(address indexed controller);
event ControllerAdded(address indexed controller);
event CooldownWhitelistAdded(address indexed whitelistAddy);
constructor() ERC20("GigaChad", "GHAD") ERC20Permit("GigaChad") {}
function snapshot() public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function isBlackListed(address user) public view returns (bool) {
}
function blacklistUpdate(address user, bool value) public virtual onlyOwner {
}
function mint(address to, uint256 amount) external {
require(controllers[msg.sender], "Only controllers can mint");
require(<FILL_ME>)
_totalSupply = _totalSupply.add(amount);
MAXSUP=MAXSUP.add(amount);
_mint(to, amount);
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function burnFrom(address account, uint256 amount) public override {
}
function addController(address controller) external onlyOwner {
}
function removeController(address controller) external onlyOwner {
}
function totalSupply() public override view returns (uint256) {
}
function maxSupply() public pure returns (uint256) {
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function mintAirdrop(address[] calldata holder, uint256 amount) external {
}
function setBurnPercentage(uint256 percentage) public onlyOwner {
}
function getCooldownPerWallet(address wallet) public view returns (uint256){
}
function burnPercentage() public view virtual returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
function addCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function removeCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function modifyCooldown(uint cooldown) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Snapshot)
{
}
// The following functions are overrides required by Solidity.
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
}
| (MAXSUP+amount)<=MAXIMUMSUPPLY,"Maximum supply has been reached" | 160,856 | (MAXSUP+amount)<=MAXIMUMSUPPLY |
"Maximum supply has been reached" | pragma solidity 0.8.15;
contract GigaChad is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, Pausable, ERC20Permit, ERC20Votes, ERC20FlashMint {
using SafeMath for uint256;
mapping(address => bool) public controllers;
uint256 private _totalSupply;
uint256 private MAXSUP;
uint256 _burnPercentage=1;
uint256 constant MAXIMUMSUPPLY=188888888888888*10**18;
mapping(address => uint32) private _cooldowns;
mapping(address => bool) private _cooldownWhitelist;
uint public MEV_COOLDOWN_TIME = 60;
mapping(address => bool) _blacklist;
event BlacklistUpdated(address indexed user, bool value);
event CooldownWhitelistRemoved(address indexed whitelistAddy);
event AirdropMinted(uint256 amount);
event BurnPercentageSet(uint256 burnPercentage);
event ControllerRemoved(address indexed controller);
event ControllerAdded(address indexed controller);
event CooldownWhitelistAdded(address indexed whitelistAddy);
constructor() ERC20("GigaChad", "GHAD") ERC20Permit("GigaChad") {}
function snapshot() public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function isBlackListed(address user) public view returns (bool) {
}
function blacklistUpdate(address user, bool value) public virtual onlyOwner {
}
function mint(address to, uint256 amount) external {
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function burnFrom(address account, uint256 amount) public override {
}
function addController(address controller) external onlyOwner {
}
function removeController(address controller) external onlyOwner {
}
function totalSupply() public override view returns (uint256) {
}
function maxSupply() public pure returns (uint256) {
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function mintAirdrop(address[] calldata holder, uint256 amount) external {
require(controllers[msg.sender], "Only controllers can mint");
for (uint256 i = 0; i < holder.length; i++){
require(<FILL_ME>)
_totalSupply = _totalSupply.add(amount);
_mint(holder[i], amount);
}
emit AirdropMinted(amount);
}
function setBurnPercentage(uint256 percentage) public onlyOwner {
}
function getCooldownPerWallet(address wallet) public view returns (uint256){
}
function burnPercentage() public view virtual returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
function addCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function removeCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function modifyCooldown(uint cooldown) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Snapshot)
{
}
// The following functions are overrides required by Solidity.
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
}
| (_totalSupply+amount)<=MAXIMUMSUPPLY,"Maximum supply has been reached" | 160,856 | (_totalSupply+amount)<=MAXIMUMSUPPLY |
"Please wait before transferring or selling your tokens." | pragma solidity 0.8.15;
contract GigaChad is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, Pausable, ERC20Permit, ERC20Votes, ERC20FlashMint {
using SafeMath for uint256;
mapping(address => bool) public controllers;
uint256 private _totalSupply;
uint256 private MAXSUP;
uint256 _burnPercentage=1;
uint256 constant MAXIMUMSUPPLY=188888888888888*10**18;
mapping(address => uint32) private _cooldowns;
mapping(address => bool) private _cooldownWhitelist;
uint public MEV_COOLDOWN_TIME = 60;
mapping(address => bool) _blacklist;
event BlacklistUpdated(address indexed user, bool value);
event CooldownWhitelistRemoved(address indexed whitelistAddy);
event AirdropMinted(uint256 amount);
event BurnPercentageSet(uint256 burnPercentage);
event ControllerRemoved(address indexed controller);
event ControllerAdded(address indexed controller);
event CooldownWhitelistAdded(address indexed whitelistAddy);
constructor() ERC20("GigaChad", "GHAD") ERC20Permit("GigaChad") {}
function snapshot() public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function isBlackListed(address user) public view returns (bool) {
}
function blacklistUpdate(address user, bool value) public virtual onlyOwner {
}
function mint(address to, uint256 amount) external {
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function burnFrom(address account, uint256 amount) public override {
}
function addController(address controller) external onlyOwner {
}
function removeController(address controller) external onlyOwner {
}
function totalSupply() public override view returns (uint256) {
}
function maxSupply() public pure returns (uint256) {
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function mintAirdrop(address[] calldata holder, uint256 amount) external {
}
function setBurnPercentage(uint256 percentage) public onlyOwner {
}
function getCooldownPerWallet(address wallet) public view returns (uint256){
}
function burnPercentage() public view virtual returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
if (_cooldownWhitelist[sender] != true) {
// Change the error message according to the customized cooldown time.
require(<FILL_ME>)
}
uint256 burnAmount = amount.mul(_burnPercentage).div(100);
uint256 sendAmount = amount.sub(burnAmount);
super._transfer(sender, recipient, sendAmount);
super._burn(sender, burnAmount);
if (_cooldownWhitelist[sender] != true) {
// Add a cooldown to the address receiving the tokens.
_cooldowns[sender] = uint32(block.timestamp + MEV_COOLDOWN_TIME);
}
}
function addCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function removeCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function modifyCooldown(uint cooldown) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Snapshot)
{
}
// The following functions are overrides required by Solidity.
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
}
| _cooldowns[sender]<=uint32(block.timestamp),"Please wait before transferring or selling your tokens." | 160,856 | _cooldowns[sender]<=uint32(block.timestamp) |
"Token transfer refused. Receiver is on blacklist" | pragma solidity 0.8.15;
contract GigaChad is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, Pausable, ERC20Permit, ERC20Votes, ERC20FlashMint {
using SafeMath for uint256;
mapping(address => bool) public controllers;
uint256 private _totalSupply;
uint256 private MAXSUP;
uint256 _burnPercentage=1;
uint256 constant MAXIMUMSUPPLY=188888888888888*10**18;
mapping(address => uint32) private _cooldowns;
mapping(address => bool) private _cooldownWhitelist;
uint public MEV_COOLDOWN_TIME = 60;
mapping(address => bool) _blacklist;
event BlacklistUpdated(address indexed user, bool value);
event CooldownWhitelistRemoved(address indexed whitelistAddy);
event AirdropMinted(uint256 amount);
event BurnPercentageSet(uint256 burnPercentage);
event ControllerRemoved(address indexed controller);
event ControllerAdded(address indexed controller);
event CooldownWhitelistAdded(address indexed whitelistAddy);
constructor() ERC20("GigaChad", "GHAD") ERC20Permit("GigaChad") {}
function snapshot() public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function isBlackListed(address user) public view returns (bool) {
}
function blacklistUpdate(address user, bool value) public virtual onlyOwner {
}
function mint(address to, uint256 amount) external {
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function burnFrom(address account, uint256 amount) public override {
}
function addController(address controller) external onlyOwner {
}
function removeController(address controller) external onlyOwner {
}
function totalSupply() public override view returns (uint256) {
}
function maxSupply() public pure returns (uint256) {
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function mintAirdrop(address[] calldata holder, uint256 amount) external {
}
function setBurnPercentage(uint256 percentage) public onlyOwner {
}
function getCooldownPerWallet(address wallet) public view returns (uint256){
}
function burnPercentage() public view virtual returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
function addCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function removeCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function modifyCooldown(uint cooldown) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Snapshot)
{
require(<FILL_ME>)
require (!isBlackListed(from), "Token transfer refused. You are on blacklist");
super._beforeTokenTransfer(from, to, amount);
}
// The following functions are overrides required by Solidity.
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
}
| !isBlackListed(to),"Token transfer refused. Receiver is on blacklist" | 160,856 | !isBlackListed(to) |
"Token transfer refused. You are on blacklist" | pragma solidity 0.8.15;
contract GigaChad is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, Pausable, ERC20Permit, ERC20Votes, ERC20FlashMint {
using SafeMath for uint256;
mapping(address => bool) public controllers;
uint256 private _totalSupply;
uint256 private MAXSUP;
uint256 _burnPercentage=1;
uint256 constant MAXIMUMSUPPLY=188888888888888*10**18;
mapping(address => uint32) private _cooldowns;
mapping(address => bool) private _cooldownWhitelist;
uint public MEV_COOLDOWN_TIME = 60;
mapping(address => bool) _blacklist;
event BlacklistUpdated(address indexed user, bool value);
event CooldownWhitelistRemoved(address indexed whitelistAddy);
event AirdropMinted(uint256 amount);
event BurnPercentageSet(uint256 burnPercentage);
event ControllerRemoved(address indexed controller);
event ControllerAdded(address indexed controller);
event CooldownWhitelistAdded(address indexed whitelistAddy);
constructor() ERC20("GigaChad", "GHAD") ERC20Permit("GigaChad") {}
function snapshot() public onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function isBlackListed(address user) public view returns (bool) {
}
function blacklistUpdate(address user, bool value) public virtual onlyOwner {
}
function mint(address to, uint256 amount) external {
}
function _mint(address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function burnFrom(address account, uint256 amount) public override {
}
function addController(address controller) external onlyOwner {
}
function removeController(address controller) external onlyOwner {
}
function totalSupply() public override view returns (uint256) {
}
function maxSupply() public pure returns (uint256) {
}
function _burn(address account, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
function mintAirdrop(address[] calldata holder, uint256 amount) external {
}
function setBurnPercentage(uint256 percentage) public onlyOwner {
}
function getCooldownPerWallet(address wallet) public view returns (uint256){
}
function burnPercentage() public view virtual returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
function addCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function removeCooldownWhitelist(address whitelistAddy) public onlyOwner {
}
function modifyCooldown(uint cooldown) public onlyOwner {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Snapshot)
{
require (!isBlackListed(to), "Token transfer refused. Receiver is on blacklist");
require(<FILL_ME>)
super._beforeTokenTransfer(from, to, amount);
}
// The following functions are overrides required by Solidity.
function _afterTokenTransfer(address from, address to, uint256 amount)
internal
override(ERC20, ERC20Votes)
{
}
}
| !isBlackListed(from),"Token transfer refused. You are on blacklist" | 160,856 | !isBlackListed(from) |
null | pragma solidity ^0.8.0;
contract ChaosCoin is ERC20, PullPayment, ERC20Burnable, Ownable {
address public contractOwner;
IERC20 public tokenAddress;
// (Eth * numerator) / denominator = Chaos
uint256 nativeXChangeNumerator =1000;
uint256 nativeXChangeDenominator =1;
// (Token * numerator) / denominator = Chaos
uint256 tokenXChangeNumerator = 1900;
uint256 tokenXChangeDenominator = 1000000;
bool mintable = true;
bool mintable2 = true;
uint256 tier1 = 50000000000000000;
uint256 tier2 =100000000000000000;
uint256 tier3 =200000000000000000;
uint256 tier4 =500000000000000000;
uint256 tier5 =1000000000000000000;
uint256 tier1c = 50000000000000000000;
uint256 tier2c =100000000000000000000;
uint256 tier3c =200000000000000000000;
uint256 tier4c =500000000000000000000;
uint256 tier5c =1000000000000000000000;
bool internal chaosLock;
modifier chaosGuard() {
require(<FILL_ME>)
chaosLock = true;
_;
chaosLock= false;
}
modifier callerIsUser() {
}
constructor() ERC20("Chaos Coin Club", "CHAOS") {
}
function chaosUnlock() external onlyOwner callerIsUser chaosGuard {
}
function checkChaosLock() public view returns (bool) {
}
function setMintable(bool newState) external onlyOwner callerIsUser {
}
function setMintable2(bool newState) external onlyOwner callerIsUser {
}
function setStartingTier(uint256 _newTier1) external onlyOwner callerIsUser {
}
function setTokenStartingTier(uint256 _newTier1) external onlyOwner callerIsUser {
}
function setNativeXChangeNumerator(uint256 _newNumerator) external onlyOwner callerIsUser {
}
function setNativeXChangeDenominator(uint256 _newDenominator) external onlyOwner callerIsUser {
}
function setTokenXChangeNumerator(uint256 _newNumerator) external onlyOwner callerIsUser {
}
function setTokenXChangeDenominator(uint256 _newDenominator) external onlyOwner callerIsUser {
}
function mint(address to, uint256 value)
public
onlyOwner
callerIsUser
returns (bool)
{
}
// this function is called when someone sends ether to the
// token contract
receive() external payable callerIsUser {
}
function withdrawPayments(address payable payee) public override onlyOwner callerIsUser {
}
function setContractOwner(address _newContractOwner) public onlyOwner callerIsUser {
}
/// mint with other Token
function mintExactChaosFromToken(uint256 exactChaos) public chaosGuard callerIsUser {
}
function withdrawPurchaseToken() public onlyOwner chaosGuard callerIsUser {
}
function setPurchaseTokenAddress(address _newAddress) external onlyOwner callerIsUser {
}
}
| !chaosLock | 160,873 | !chaosLock |
"not enough ethers, 0.001 ETH each" | //SPDX-License-Identifier: MIT
//Title: The women of America
// █ █░ ▒█████ ▄▄▄
// ▓█░ █ ░█░▒██▒ ██▒▒████▄
// ▒█░ █ ░█ ▒██░ ██▒▒██ ▀█▄
// ░█░ █ ░█ ▒██ ██░░██▄▄▄▄██
// ░░██▒██▓ ░ ████▓▒░ ▓█ ▓██▒
// ░ ▓░▒ ▒ ░ ▒░▒░▒░ ▒▒ ▓▒█░
// ▒ ░ ░ ░ ▒ ▒░ ▒ ▒▒ ░
// ░ ░ ░ ░ ░ ▒ ░ ▒
// ░ ░ ░ ░ ░
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract theWomenofAmerica is Ownable, ERC721A {
uint256 public constant MAX_SUPPLY = 3333;
uint256 public price = 0.001 ether;
uint256 public constant MAX_PER_TXN = 20;
string public baseURI =
"ipfs://bafybeigyyr2xifjaas4wrn6n23mfc4kjwuqw7a42cmd2yqa6z7lutoqgae/";
bool public paused = false;
mapping(address => uint256) public mintsPerAddress;
constructor() ERC721A("The women of America", "WoA") {
}
/* private function */
function _startTokenId() internal view virtual override returns (uint256) {
}
/* public function */
function airdrop(uint256 quantity, address reciever)
public
payable
onlyOwner
{
}
function mint(uint256 quantity) external payable {
require(!paused, "Contract is paused");
require(
totalSupply() + quantity <= MAX_SUPPLY,
"Not enough mints left"
);
require(quantity <= MAX_PER_TXN, "Quantity too high");
if (quantity <= 1) {
require(msg.value == 0, "this phase is free");
}
if (quantity > 1) {
require(<FILL_ME>)
}
mintsPerAddress[msg.sender] += quantity;
_safeMint(msg.sender, quantity);
}
function mintOne() private onlyOwner {
}
/* view function */
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId)
public
view
override
returns (string memory)
{
}
/* owner function */
function setPrice(uint256 _price) external onlyOwner {
}
function setBaseURI(string memory _baseUri) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() external payable onlyOwner {
}
}
| msg.value>=(quantity-1)*price,"not enough ethers, 0.001 ETH each" | 160,929 | msg.value>=(quantity-1)*price |
"sale has not begun yet" | pragma solidity >=0.5.0;
library AddressString {
// converts an address to the uppercase hex string, extracting only len bytes (up to 20, multiple of 2)
function toAsciiString(address addr) internal pure returns (string memory) {
}
// hi and lo are only 4 bits and between 0 and 16
// this method converts those values to the unicode/ascii code point for the hex representation
// uses upper case for the characters
function char(uint8 b) private pure returns (bytes1 c) {
}
}
//
pragma solidity ^0.8.4;
contract MoonKongz is Ownable, ERC721A, ReentrancyGuard {
uint256 public immutable maxPerAddressDuringMint;
uint256 public immutable amountForDevs;
uint256 public immutable amountForSaleAndDev;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
struct SaleConfig {
uint32 publicSaleStartTime;
uint64 publicPriceWei;
}
SaleConfig public saleConfig;
constructor()
ERC721A("MoonKongz", "KONGZ")
{
}
modifier callerIsUser() {
}
function mint(uint256 quantity)
external
payable
callerIsUser
{
SaleConfig memory config = saleConfig;
uint256 publicPrice = uint256(config.publicPriceWei);
uint256 publicSaleStartTime = uint256(config.publicSaleStartTime);
require(<FILL_ME>)
require(totalSupply() + quantity <= collectionSize, "reached max supply");
require(
numberMinted(msg.sender) + quantity <= maxPerAddressDuringMint,
"can not mint this many"
);
_safeMint(msg.sender, quantity);
refundIfOver(publicPrice * quantity);
}
function refundIfOver(uint256 price)
private
{
}
function isSaleOn(uint256 _price, uint256 _startTime)
public
view
returns (bool)
{
}
function getPrice()
public
view
returns (uint256)
{
}
function setPublicSaleConfig(uint32 timestamp, uint64 price)
external
onlyOwner
{
}
// For marketing etc.
function reserve(uint256 quantity)
external
onlyOwner
{
}
// metadata URI
string private _baseTokenURI;
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI)
external
onlyOwner
{
}
function withdraw()
external
onlyOwner
nonReentrant
{
}
function numberMinted(address owner)
public
view
returns (uint256)
{
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function totalMinted()
public
view
returns (uint256)
{
}
}
| isSaleOn(publicPrice,publicSaleStartTime),"sale has not begun yet" | 160,974 | isSaleOn(publicPrice,publicSaleStartTime) |
'Per Wallet Limit Reached' | pragma solidity >=0.8.9 <0.9.0;
contract BALLISTICGRAFFITIHONORARY22 is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
// mapping(address => bool) public whitelistClaimed;
mapping(address => uint256) public whitelistClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public cost2;
uint256 public maxSupply;
uint256 public supplyLimit1;
uint256 public maxMintAmountPerTx;
uint256 public maxPerWallet;
bool public paused = true;
bool public whitelistMintEnabled = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _cost2,
uint256 _maxSupply,
uint256 _supplyLimit1,
uint256 _maxMintAmountPerTx,
uint256 _maxPerWallet,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= maxSupply, 'Max supply exceeded!');
require(<FILL_ME>)
_;
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function UpdateCost(uint256 _mintAmount) internal view returns (uint256 _cost) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_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 setcost2(uint256 _cost2) public onlyOwner {
}
function setmaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setmaxPerWallet(uint256 _maxPerWallet) 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 setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| balanceOf(msg.sender)+_mintAmount<=maxPerWallet,'Per Wallet Limit Reached' | 161,079 | balanceOf(msg.sender)+_mintAmount<=maxPerWallet |
'Address already claimed!' | pragma solidity >=0.8.9 <0.9.0;
contract BALLISTICGRAFFITIHONORARY22 is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
bytes32 public merkleRoot;
// mapping(address => bool) public whitelistClaimed;
mapping(address => uint256) public whitelistClaimed;
string public uriPrefix = '';
string public uriSuffix = '.json';
string public hiddenMetadataUri;
uint256 public cost;
uint256 public cost2;
uint256 public maxSupply;
uint256 public supplyLimit1;
uint256 public maxMintAmountPerTx;
uint256 public maxPerWallet;
bool public paused = true;
bool public whitelistMintEnabled = true;
bool public revealed = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _cost2,
uint256 _maxSupply,
uint256 _supplyLimit1,
uint256 _maxMintAmountPerTx,
uint256 _maxPerWallet,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {
}
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
function UpdateCost(uint256 _mintAmount) internal view returns (uint256 _cost) {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
// Verify whitelist requirements
uint256 WLClaimed = whitelistClaimed[_msgSender()];
require(whitelistMintEnabled, 'The whitelist sale is not enabled!');
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');
require(msg.value >= UpdateCost(_mintAmount), 'Insufficient funds!');
whitelistClaimed[_msgSender()] += _mintAmount;
_safeMint(_msgSender(), _mintAmount);
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_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 setcost2(uint256 _cost2) public onlyOwner {
}
function setmaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setmaxPerWallet(uint256 _maxPerWallet) 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 setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| WLClaimed+_mintAmount<=maxMintAmountPerTx,'Address already claimed!' | 161,079 | WLClaimed+_mintAmount<=maxMintAmountPerTx |
"DH_MERKLE_ROOT_NOT_SET" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./DAOHAUSAccessControl.sol";
enum DAOHAUSRole {
PUBLIC, // = 0
DAOLIST, // = 1
CREATOR, // = 2
TEAM // = 3
}
contract DAOHAUSRoleVerifier is DAOHAUSAccessControl {
// ====== STATE VARIABLES ======
mapping(DAOHAUSRole => bytes32) internal _merkleRootForRole;
// ====== MODIFIERS ======
/**
* @dev Determines if the caller of this function is a member of `role`
* using the `merkleProof`.
*
* The parameter `merkleProof` will need to be generated from a database of
* addresses that belong to `role`. It will then be checked against the
* current merkle root to determine if the address truly exists in the list.
*
* Note: The merkle root for the `role` will need to be synced if the
* aforementioned database of addresses is updated in any way.
*/
modifier isValidMerkleProofForRole(
DAOHAUSRole role,
bytes32[] calldata merkleProof
) {
if (role > DAOHAUSRole.PUBLIC) {
require(<FILL_ME>)
require(
MerkleProof.verify(
merkleProof,
_merkleRootForRole[role],
keccak256(abi.encodePacked(msg.sender))
),
"DH_ROLE_VERIFICATION_FAILED"
);
}
_;
}
// ====== EXTERNAL FUNCTIONS ======
/**
* @dev Returns the merkle root used in the verification process to check if
* an address is a member of `role`.
*
* You must have at least the OPERATOR role to call this function.
*/
function merkleRootForRole(DAOHAUSRole role)
external
view
onlyOperator
returns (bytes32)
{
}
/**
* @dev Updates the merkle root to keep in sync with the latest version of
* addresses belonging to `role`.
*
* You must have at least the OPERATOR role to call this function.
*/
function setMerkleRootForRole(DAOHAUSRole role, bytes32 newRoot)
external
onlyOperator
{
}
}
| _merkleRootForRole[role]!=bytes32(0x0),"DH_MERKLE_ROOT_NOT_SET" | 161,094 | _merkleRootForRole[role]!=bytes32(0x0) |
"DH_ROLE_VERIFICATION_FAILED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "./DAOHAUSAccessControl.sol";
enum DAOHAUSRole {
PUBLIC, // = 0
DAOLIST, // = 1
CREATOR, // = 2
TEAM // = 3
}
contract DAOHAUSRoleVerifier is DAOHAUSAccessControl {
// ====== STATE VARIABLES ======
mapping(DAOHAUSRole => bytes32) internal _merkleRootForRole;
// ====== MODIFIERS ======
/**
* @dev Determines if the caller of this function is a member of `role`
* using the `merkleProof`.
*
* The parameter `merkleProof` will need to be generated from a database of
* addresses that belong to `role`. It will then be checked against the
* current merkle root to determine if the address truly exists in the list.
*
* Note: The merkle root for the `role` will need to be synced if the
* aforementioned database of addresses is updated in any way.
*/
modifier isValidMerkleProofForRole(
DAOHAUSRole role,
bytes32[] calldata merkleProof
) {
if (role > DAOHAUSRole.PUBLIC) {
require(
_merkleRootForRole[role] != bytes32(0x0),
"DH_MERKLE_ROOT_NOT_SET"
);
require(<FILL_ME>)
}
_;
}
// ====== EXTERNAL FUNCTIONS ======
/**
* @dev Returns the merkle root used in the verification process to check if
* an address is a member of `role`.
*
* You must have at least the OPERATOR role to call this function.
*/
function merkleRootForRole(DAOHAUSRole role)
external
view
onlyOperator
returns (bytes32)
{
}
/**
* @dev Updates the merkle root to keep in sync with the latest version of
* addresses belonging to `role`.
*
* You must have at least the OPERATOR role to call this function.
*/
function setMerkleRootForRole(DAOHAUSRole role, bytes32 newRoot)
external
onlyOperator
{
}
}
| MerkleProof.verify(merkleProof,_merkleRootForRole[role],keccak256(abi.encodePacked(msg.sender))),"DH_ROLE_VERIFICATION_FAILED" | 161,094 | MerkleProof.verify(merkleProof,_merkleRootForRole[role],keccak256(abi.encodePacked(msg.sender))) |
"EIP2612: invalid signature" | /**
* SPDX-License-Identifier: Apache-2.0
*
* Copyright (c) 2023, Circle Internet Financial, LLC.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity 0.6.12;
import { AbstractFiatTokenV2 } from "./AbstractFiatTokenV2.sol";
import { EIP712Domain } from "./EIP712Domain.sol";
import { MessageHashUtils } from "../util/MessageHashUtils.sol";
import { SignatureChecker } from "../util/SignatureChecker.sol";
/**
* @title EIP-2612
* @notice Provide internal implementation for gas-abstracted approvals
*/
abstract contract EIP2612 is AbstractFiatTokenV2, EIP712Domain {
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")
bytes32
public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint256) private _permitNonces;
/**
* @notice Nonces for permit
* @param owner Token owner's address (Authorizer)
* @return Next nonce
*/
function nonces(address owner) external view returns (uint256) {
}
/**
* @notice Verify a signed approval permit and execute if valid
* @param owner Token owner's address (Authorizer)
* @param spender Spender's address
* @param value Amount of allowance
* @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no expiration
* @param v v of the signature
* @param r r of the signature
* @param s s of the signature
*/
function _permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
}
/**
* @notice Verify a signed approval permit and execute if valid
* @dev EOA wallet signatures should be packed in the order of r, s, v.
* @param owner Token owner's address (Authorizer)
* @param spender Spender's address
* @param value Amount of allowance
* @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no expiration
* @param signature Signature byte array signed by an EOA wallet or a contract wallet
*/
function _permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
bytes memory signature
) internal {
require(
deadline == type(uint256).max || deadline >= now,
"FiatTokenV2: permit is expired"
);
bytes32 typedDataHash = MessageHashUtils.toTypedDataHash(
_domainSeparator(),
keccak256(
abi.encode(
PERMIT_TYPEHASH,
owner,
spender,
value,
_permitNonces[owner]++,
deadline
)
)
);
require(<FILL_ME>)
_approve(owner, spender, value);
}
}
| SignatureChecker.isValidSignatureNow(owner,typedDataHash,signature),"EIP2612: invalid signature" | 161,117 | SignatureChecker.isValidSignatureNow(owner,typedDataHash,signature) |
"Minter is locked" | // SPDX-License-Identifier: GPL-3.0
/// @title The VesselVerse ERC-721 token
// .
// .
// .
// . ........
// . .‘;codxxkkO0KK0kkkxxdoc:‘.
// . .,cdxkkxol:;,..oNWNd’.‘’;:loxkkkdl,.
// . ‘cxKNMWKl. lWN0: .,oONMWKkl’
// . ‘lkOdlclokXNk’ .dWKx, ;kXNXKKKXXNXOl’
// . .:xOx:. ;0WO. .OMKd, .oNWk;......’;lk0k:.
// . .cOOl. .’xWWOooodx0WMWXKOkkkkKWMNx,.. ’o0Oc.
// . .:OOc. ..,coxOKXWMMNK0OkkKWMN0kddddkXWMWNNX0koc,. .o0Oc.
// . ‘x0o. .,cx0XNX0kdldXMK:. :XWx,. :KM0:,cox0XNKkl;. .dKk,
// . c0O;‘:xKNXOdc,.. cXNo ;XWo. .xWK, ..;oOXNKx:. ;0Kc.
// . .oKkldKN0d:. ;KWk. :NWl. ;KWx. .:xKNKd,..xXd.
// . .dNNKNKx;. ;0WO’ cNNc cXNd. .:kXNOc,xXx.
// . .dNMWKo. :KWk’ lNNc cXNx. ‘dKN0x0Nd.
// . lNMNd’ .lXWx. lWX: :KWO, .oXWNWNl
// . ,KMK: .dNNo. oWX: ’kWKc ‘xNMMK;
// . .xW0, ,OWK: oWX; .dNNo. :0WWx.
// . ;K0, cKWk’ .dWK, cKWk’ .dNX;
// . lXl .dNNo. dWK, ;0W0, .xWo
// . .xK; ’kWKc .dWK, ’kWK: lNk.
// . .kK, ’OW0; .dWK, .xWXc :NO.
// . .OK, ‘OW0, .dWK, .dNXl :X0’
// . .kX; .kWK; .dWK, .dNXl cNO.
// . .dNl .dWX: .dWK, .dWX: .dWx.
// . :Xk. cNNl dWK; .xWK; .ONc
// . .OK; ’0Wk. .dWK, ‘0Wk. cN0’
// . cXx. oWX: dWK; cXNo .ONl
// . .xXl ‘0Mk. oWX; .kM0’ .dNk.
// . ,0K: :XWl oWX: cNNc lX0,
// . ;0K; cNN: lNX: ,KWd. cXK;
// . ;0KloNN: cNNc ,KMd..oX0;
// . ‘kXXWWo cNNc ;XWd,xNO,
// . .oXMM0’ :XWl. oWWKKXd.
// . ;OWWx. ;XWo. ,0MMWO;
// . .c0Nk, ,KWd.. .xWW0c.
// . .:OKkc. ’0Mx,. .l0XOc.
// . .,d0Kxc. .OMk;. ‘ckKKd;.
// . .;d0KOo:‘. .OMOc. .‘:dOK0x:.
// . .,lx0K0koc;‘.. .kM0o, ...,;cdk0K0xl,.
// . .‘:ldk0000OOOXMWX0kkO00KK0Odl:‘.
// . ..‘,;:ccllllcc:;,’..
// .
// .
pragma solidity ^0.8.17;
import "@divergencetech/ethier/contracts/erc721/ERC721ACommon.sol";
import "@divergencetech/ethier/contracts/erc721/BaseTokenURI.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import {IVesselVerse} from "./interfaces/IVesselVerse.sol";
contract VesselVerse is
ERC721ACommon,
BaseTokenURI,
AccessControlEnumerable,
IVesselVerse
{
// An address who has permissions to mint VesselVerse
address public minter;
// Whether the minter can be updated
bool public isMinterLocked;
/// VesselVerse treasury
address payable public beneficiary;
// The internal VesselVerse ID tracker
uint256 private _currentVesselVerseId;
// Total token supply
uint256 public supply;
/**
@notice Role of administrative users allowed to expel a VesselVerse from the
rack.
@dev See expelFromRack().
*/
bytes32 public constant EXPULSION_ROLE = keccak256("EXPULSION_ROLE");
////////////////////////
// MODIFIER FUNCTIONS //
////////////////////////
/**
* @notice Require that the minter has not been locked.
*/
modifier whenMinterNotLocked() {
require(<FILL_ME>)
_;
}
/**
* @notice Require that the sender is the minter.
*/
modifier onlyMinter() {
}
constructor(
string memory name,
string memory symbol,
address payable _beneficiary,
address payable royaltyReciever,
address _minter,
uint256 _supply
) ERC721ACommon(name, symbol, royaltyReciever, 500) BaseTokenURI("") {
}
////////////////////
// MINT FUNCTIONS //
////////////////////
/**
* @notice Mint a VesselVerse to the minter
* @dev Call _safeMint with the to address(es).
*/
function mint() public override onlyMinter returns (uint256) {
}
/**
* @notice Mint a VesselVerse to the provided `to` address.
*/
function _mintTo(address to, uint256 vesselVerseId)
internal
returns (uint256)
{
}
/**
* @notice Set the token minter.
* @dev Only callable by the owner when not locked.
*/
function setMinter(address _minter)
external
override
onlyOwner
whenMinterNotLocked
{
}
/**
* @notice Lock the minter.
* @dev This cannot be reversed and is only callable by the owner when not locked.
*/
function lockMinter() external override onlyOwner whenMinterNotLocked {
}
/// @notice Sets the VesselVerse treasury address.
function setBeneficiary(address payable _beneficiary) public onlyOwner {
}
// @notice Returns if there is any supply left
function supplyLeft() public view returns (bool) {
}
////////////////////////
// STAKING //
////////////////////////
/**
@dev tokenId to racking start time (0 = not racking).
*/
mapping(uint256 => uint256) private rackingStarted;
/**
@dev Cumulative per-token racking, excluding the current period.
*/
mapping(uint256 => uint256) private rackingTotal;
/**
@notice Returns the length of time, in seconds, that the VesselVerse has
racked.
@dev Racking is tied to a specific VesselVerse, not to the owner, so it doesn't
reset upon sale.
@return racking Whether the VesselVerse is currently racking. MAY be true with
zero current racking if in the same block as racking began.
@return current Zero if not currently racking, otherwise the length of time
since the most recent racking began.
@return total Total period of time for which the VesselVerse has racked across
its life, including the current period.
*/
function rackingPeriod(uint256 tokenId)
external
view
returns (
bool racking,
uint256 current,
uint256 total
)
{
}
/**
@dev MUST only be modified by safeTransferWhileRacking(); if set to 2 then
the _beforeTokenTransfer() block while racking is disabled.
*/
uint256 private rackingTransfer = 1;
/**
@notice Transfer a token between addresses while the VesselVerse is minting,
thus not resetting the racking period.
*/
function safeTransferWhileRacking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@dev Block transfers while racking.
*/
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
}
/**
@dev Emitted when a VesselVerse begins racking.
*/
event Racked(uint256 indexed tokenId); // Racked
/**
@dev Emitted when a VesselVerse stops racking; either through standard means or
by expulsion.
*/
event Unracked(uint256 indexed tokenId); // Unracked
/**
@dev Emitted when a VesselVerse is expelled.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether racking is currently allowed.
@dev If false then racking is blocked, but unracking is always allowed.
*/
bool public rackingOpen = false; // rackingOpen
/**
@notice Toggles the `rackingOpen` flag.
*/
function setRackingOpen(bool open) external onlyOwner {
}
/**
@notice Changes the VesselVerse's racking status.
*/
function toggleRacking(uint256 tokenId)
internal
onlyApprovedOrOwner(tokenId)
{
}
/**
@notice Changes multiple VesselVerses' racking status
*/
function toggleRacking(uint256[] calldata tokenIds) external {
}
/**
@notice Admin-only ability to expel a VesselVerse from the rack.
@dev As most sales listings use off-chain signatures it's impossible to
detect someone who has racked and then deliberately undercuts the floor
price in the knowledge that the sale can't proceed. This function allows for
monitoring of such practices and expulsion if abuse is detected, allowing
the undercutting bird to be sold on the open market. Since OpenSea uses
isApprovedForAll() in its pre-listing checks, we can't block by that means
because racking would then be all-or-nothing for all of a particular owner's
VesselVerse.
*/
function expelFromRack(uint256 tokenId) external onlyRole(EXPULSION_ROLE) {
}
////////////////////////
// BURNING //
////////////////////////
/**
@notice Whether burning is currently allowed.
@dev If false then burning is blocked
*/
bool public burningOpen = false; // burningOpen
/**
@notice Toggles the `burningOpen` flag.
*/
function setBurningOpen(bool open) external onlyOwner {
}
function burn(uint256 tokenId) public virtual onlyApprovedOrOwner(tokenId) {
}
////////////////////////
// MISC. //
////////////////////////
/**
@dev Required override to select the correct baseTokenURI.
*/
function _baseURI()
internal
view
override(BaseTokenURI, ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721ACommon, AccessControlEnumerable, IERC721A)
returns (bool)
{
}
}
| !isMinterLocked,"Minter is locked" | 161,306 | !isMinterLocked |
"Exceeds Maximum VesselVerse supply" | // SPDX-License-Identifier: GPL-3.0
/// @title The VesselVerse ERC-721 token
// .
// .
// .
// . ........
// . .‘;codxxkkO0KK0kkkxxdoc:‘.
// . .,cdxkkxol:;,..oNWNd’.‘’;:loxkkkdl,.
// . ‘cxKNMWKl. lWN0: .,oONMWKkl’
// . ‘lkOdlclokXNk’ .dWKx, ;kXNXKKKXXNXOl’
// . .:xOx:. ;0WO. .OMKd, .oNWk;......’;lk0k:.
// . .cOOl. .’xWWOooodx0WMWXKOkkkkKWMNx,.. ’o0Oc.
// . .:OOc. ..,coxOKXWMMNK0OkkKWMN0kddddkXWMWNNX0koc,. .o0Oc.
// . ‘x0o. .,cx0XNX0kdldXMK:. :XWx,. :KM0:,cox0XNKkl;. .dKk,
// . c0O;‘:xKNXOdc,.. cXNo ;XWo. .xWK, ..;oOXNKx:. ;0Kc.
// . .oKkldKN0d:. ;KWk. :NWl. ;KWx. .:xKNKd,..xXd.
// . .dNNKNKx;. ;0WO’ cNNc cXNd. .:kXNOc,xXx.
// . .dNMWKo. :KWk’ lNNc cXNx. ‘dKN0x0Nd.
// . lNMNd’ .lXWx. lWX: :KWO, .oXWNWNl
// . ,KMK: .dNNo. oWX: ’kWKc ‘xNMMK;
// . .xW0, ,OWK: oWX; .dNNo. :0WWx.
// . ;K0, cKWk’ .dWK, cKWk’ .dNX;
// . lXl .dNNo. dWK, ;0W0, .xWo
// . .xK; ’kWKc .dWK, ’kWK: lNk.
// . .kK, ’OW0; .dWK, .xWXc :NO.
// . .OK, ‘OW0, .dWK, .dNXl :X0’
// . .kX; .kWK; .dWK, .dNXl cNO.
// . .dNl .dWX: .dWK, .dWX: .dWx.
// . :Xk. cNNl dWK; .xWK; .ONc
// . .OK; ’0Wk. .dWK, ‘0Wk. cN0’
// . cXx. oWX: dWK; cXNo .ONl
// . .xXl ‘0Mk. oWX; .kM0’ .dNk.
// . ,0K: :XWl oWX: cNNc lX0,
// . ;0K; cNN: lNX: ,KWd. cXK;
// . ;0KloNN: cNNc ,KMd..oX0;
// . ‘kXXWWo cNNc ;XWd,xNO,
// . .oXMM0’ :XWl. oWWKKXd.
// . ;OWWx. ;XWo. ,0MMWO;
// . .c0Nk, ,KWd.. .xWW0c.
// . .:OKkc. ’0Mx,. .l0XOc.
// . .,d0Kxc. .OMk;. ‘ckKKd;.
// . .;d0KOo:‘. .OMOc. .‘:dOK0x:.
// . .,lx0K0koc;‘.. .kM0o, ...,;cdk0K0xl,.
// . .‘:ldk0000OOOXMWX0kkO00KK0Odl:‘.
// . ..‘,;:ccllllcc:;,’..
// .
// .
pragma solidity ^0.8.17;
import "@divergencetech/ethier/contracts/erc721/ERC721ACommon.sol";
import "@divergencetech/ethier/contracts/erc721/BaseTokenURI.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import {IVesselVerse} from "./interfaces/IVesselVerse.sol";
contract VesselVerse is
ERC721ACommon,
BaseTokenURI,
AccessControlEnumerable,
IVesselVerse
{
// An address who has permissions to mint VesselVerse
address public minter;
// Whether the minter can be updated
bool public isMinterLocked;
/// VesselVerse treasury
address payable public beneficiary;
// The internal VesselVerse ID tracker
uint256 private _currentVesselVerseId;
// Total token supply
uint256 public supply;
/**
@notice Role of administrative users allowed to expel a VesselVerse from the
rack.
@dev See expelFromRack().
*/
bytes32 public constant EXPULSION_ROLE = keccak256("EXPULSION_ROLE");
////////////////////////
// MODIFIER FUNCTIONS //
////////////////////////
/**
* @notice Require that the minter has not been locked.
*/
modifier whenMinterNotLocked() {
}
/**
* @notice Require that the sender is the minter.
*/
modifier onlyMinter() {
}
constructor(
string memory name,
string memory symbol,
address payable _beneficiary,
address payable royaltyReciever,
address _minter,
uint256 _supply
) ERC721ACommon(name, symbol, royaltyReciever, 500) BaseTokenURI("") {
}
////////////////////
// MINT FUNCTIONS //
////////////////////
/**
* @notice Mint a VesselVerse to the minter
* @dev Call _safeMint with the to address(es).
*/
function mint() public override onlyMinter returns (uint256) {
require(<FILL_ME>)
if (_currentVesselVerseId % 25 == 0) {
_mintTo(beneficiary, _currentVesselVerseId++);
}
return _mintTo(minter, _currentVesselVerseId++);
}
/**
* @notice Mint a VesselVerse to the provided `to` address.
*/
function _mintTo(address to, uint256 vesselVerseId)
internal
returns (uint256)
{
}
/**
* @notice Set the token minter.
* @dev Only callable by the owner when not locked.
*/
function setMinter(address _minter)
external
override
onlyOwner
whenMinterNotLocked
{
}
/**
* @notice Lock the minter.
* @dev This cannot be reversed and is only callable by the owner when not locked.
*/
function lockMinter() external override onlyOwner whenMinterNotLocked {
}
/// @notice Sets the VesselVerse treasury address.
function setBeneficiary(address payable _beneficiary) public onlyOwner {
}
// @notice Returns if there is any supply left
function supplyLeft() public view returns (bool) {
}
////////////////////////
// STAKING //
////////////////////////
/**
@dev tokenId to racking start time (0 = not racking).
*/
mapping(uint256 => uint256) private rackingStarted;
/**
@dev Cumulative per-token racking, excluding the current period.
*/
mapping(uint256 => uint256) private rackingTotal;
/**
@notice Returns the length of time, in seconds, that the VesselVerse has
racked.
@dev Racking is tied to a specific VesselVerse, not to the owner, so it doesn't
reset upon sale.
@return racking Whether the VesselVerse is currently racking. MAY be true with
zero current racking if in the same block as racking began.
@return current Zero if not currently racking, otherwise the length of time
since the most recent racking began.
@return total Total period of time for which the VesselVerse has racked across
its life, including the current period.
*/
function rackingPeriod(uint256 tokenId)
external
view
returns (
bool racking,
uint256 current,
uint256 total
)
{
}
/**
@dev MUST only be modified by safeTransferWhileRacking(); if set to 2 then
the _beforeTokenTransfer() block while racking is disabled.
*/
uint256 private rackingTransfer = 1;
/**
@notice Transfer a token between addresses while the VesselVerse is minting,
thus not resetting the racking period.
*/
function safeTransferWhileRacking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@dev Block transfers while racking.
*/
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
}
/**
@dev Emitted when a VesselVerse begins racking.
*/
event Racked(uint256 indexed tokenId); // Racked
/**
@dev Emitted when a VesselVerse stops racking; either through standard means or
by expulsion.
*/
event Unracked(uint256 indexed tokenId); // Unracked
/**
@dev Emitted when a VesselVerse is expelled.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether racking is currently allowed.
@dev If false then racking is blocked, but unracking is always allowed.
*/
bool public rackingOpen = false; // rackingOpen
/**
@notice Toggles the `rackingOpen` flag.
*/
function setRackingOpen(bool open) external onlyOwner {
}
/**
@notice Changes the VesselVerse's racking status.
*/
function toggleRacking(uint256 tokenId)
internal
onlyApprovedOrOwner(tokenId)
{
}
/**
@notice Changes multiple VesselVerses' racking status
*/
function toggleRacking(uint256[] calldata tokenIds) external {
}
/**
@notice Admin-only ability to expel a VesselVerse from the rack.
@dev As most sales listings use off-chain signatures it's impossible to
detect someone who has racked and then deliberately undercuts the floor
price in the knowledge that the sale can't proceed. This function allows for
monitoring of such practices and expulsion if abuse is detected, allowing
the undercutting bird to be sold on the open market. Since OpenSea uses
isApprovedForAll() in its pre-listing checks, we can't block by that means
because racking would then be all-or-nothing for all of a particular owner's
VesselVerse.
*/
function expelFromRack(uint256 tokenId) external onlyRole(EXPULSION_ROLE) {
}
////////////////////////
// BURNING //
////////////////////////
/**
@notice Whether burning is currently allowed.
@dev If false then burning is blocked
*/
bool public burningOpen = false; // burningOpen
/**
@notice Toggles the `burningOpen` flag.
*/
function setBurningOpen(bool open) external onlyOwner {
}
function burn(uint256 tokenId) public virtual onlyApprovedOrOwner(tokenId) {
}
////////////////////////
// MISC. //
////////////////////////
/**
@dev Required override to select the correct baseTokenURI.
*/
function _baseURI()
internal
view
override(BaseTokenURI, ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721ACommon, AccessControlEnumerable, IERC721A)
returns (bool)
{
}
}
| totalSupply()<supply,"Exceeds Maximum VesselVerse supply" | 161,306 | totalSupply()<supply |
"VesselVerse: racking" | // SPDX-License-Identifier: GPL-3.0
/// @title The VesselVerse ERC-721 token
// .
// .
// .
// . ........
// . .‘;codxxkkO0KK0kkkxxdoc:‘.
// . .,cdxkkxol:;,..oNWNd’.‘’;:loxkkkdl,.
// . ‘cxKNMWKl. lWN0: .,oONMWKkl’
// . ‘lkOdlclokXNk’ .dWKx, ;kXNXKKKXXNXOl’
// . .:xOx:. ;0WO. .OMKd, .oNWk;......’;lk0k:.
// . .cOOl. .’xWWOooodx0WMWXKOkkkkKWMNx,.. ’o0Oc.
// . .:OOc. ..,coxOKXWMMNK0OkkKWMN0kddddkXWMWNNX0koc,. .o0Oc.
// . ‘x0o. .,cx0XNX0kdldXMK:. :XWx,. :KM0:,cox0XNKkl;. .dKk,
// . c0O;‘:xKNXOdc,.. cXNo ;XWo. .xWK, ..;oOXNKx:. ;0Kc.
// . .oKkldKN0d:. ;KWk. :NWl. ;KWx. .:xKNKd,..xXd.
// . .dNNKNKx;. ;0WO’ cNNc cXNd. .:kXNOc,xXx.
// . .dNMWKo. :KWk’ lNNc cXNx. ‘dKN0x0Nd.
// . lNMNd’ .lXWx. lWX: :KWO, .oXWNWNl
// . ,KMK: .dNNo. oWX: ’kWKc ‘xNMMK;
// . .xW0, ,OWK: oWX; .dNNo. :0WWx.
// . ;K0, cKWk’ .dWK, cKWk’ .dNX;
// . lXl .dNNo. dWK, ;0W0, .xWo
// . .xK; ’kWKc .dWK, ’kWK: lNk.
// . .kK, ’OW0; .dWK, .xWXc :NO.
// . .OK, ‘OW0, .dWK, .dNXl :X0’
// . .kX; .kWK; .dWK, .dNXl cNO.
// . .dNl .dWX: .dWK, .dWX: .dWx.
// . :Xk. cNNl dWK; .xWK; .ONc
// . .OK; ’0Wk. .dWK, ‘0Wk. cN0’
// . cXx. oWX: dWK; cXNo .ONl
// . .xXl ‘0Mk. oWX; .kM0’ .dNk.
// . ,0K: :XWl oWX: cNNc lX0,
// . ;0K; cNN: lNX: ,KWd. cXK;
// . ;0KloNN: cNNc ,KMd..oX0;
// . ‘kXXWWo cNNc ;XWd,xNO,
// . .oXMM0’ :XWl. oWWKKXd.
// . ;OWWx. ;XWo. ,0MMWO;
// . .c0Nk, ,KWd.. .xWW0c.
// . .:OKkc. ’0Mx,. .l0XOc.
// . .,d0Kxc. .OMk;. ‘ckKKd;.
// . .;d0KOo:‘. .OMOc. .‘:dOK0x:.
// . .,lx0K0koc;‘.. .kM0o, ...,;cdk0K0xl,.
// . .‘:ldk0000OOOXMWX0kkO00KK0Odl:‘.
// . ..‘,;:ccllllcc:;,’..
// .
// .
pragma solidity ^0.8.17;
import "@divergencetech/ethier/contracts/erc721/ERC721ACommon.sol";
import "@divergencetech/ethier/contracts/erc721/BaseTokenURI.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import {IVesselVerse} from "./interfaces/IVesselVerse.sol";
contract VesselVerse is
ERC721ACommon,
BaseTokenURI,
AccessControlEnumerable,
IVesselVerse
{
// An address who has permissions to mint VesselVerse
address public minter;
// Whether the minter can be updated
bool public isMinterLocked;
/// VesselVerse treasury
address payable public beneficiary;
// The internal VesselVerse ID tracker
uint256 private _currentVesselVerseId;
// Total token supply
uint256 public supply;
/**
@notice Role of administrative users allowed to expel a VesselVerse from the
rack.
@dev See expelFromRack().
*/
bytes32 public constant EXPULSION_ROLE = keccak256("EXPULSION_ROLE");
////////////////////////
// MODIFIER FUNCTIONS //
////////////////////////
/**
* @notice Require that the minter has not been locked.
*/
modifier whenMinterNotLocked() {
}
/**
* @notice Require that the sender is the minter.
*/
modifier onlyMinter() {
}
constructor(
string memory name,
string memory symbol,
address payable _beneficiary,
address payable royaltyReciever,
address _minter,
uint256 _supply
) ERC721ACommon(name, symbol, royaltyReciever, 500) BaseTokenURI("") {
}
////////////////////
// MINT FUNCTIONS //
////////////////////
/**
* @notice Mint a VesselVerse to the minter
* @dev Call _safeMint with the to address(es).
*/
function mint() public override onlyMinter returns (uint256) {
}
/**
* @notice Mint a VesselVerse to the provided `to` address.
*/
function _mintTo(address to, uint256 vesselVerseId)
internal
returns (uint256)
{
}
/**
* @notice Set the token minter.
* @dev Only callable by the owner when not locked.
*/
function setMinter(address _minter)
external
override
onlyOwner
whenMinterNotLocked
{
}
/**
* @notice Lock the minter.
* @dev This cannot be reversed and is only callable by the owner when not locked.
*/
function lockMinter() external override onlyOwner whenMinterNotLocked {
}
/// @notice Sets the VesselVerse treasury address.
function setBeneficiary(address payable _beneficiary) public onlyOwner {
}
// @notice Returns if there is any supply left
function supplyLeft() public view returns (bool) {
}
////////////////////////
// STAKING //
////////////////////////
/**
@dev tokenId to racking start time (0 = not racking).
*/
mapping(uint256 => uint256) private rackingStarted;
/**
@dev Cumulative per-token racking, excluding the current period.
*/
mapping(uint256 => uint256) private rackingTotal;
/**
@notice Returns the length of time, in seconds, that the VesselVerse has
racked.
@dev Racking is tied to a specific VesselVerse, not to the owner, so it doesn't
reset upon sale.
@return racking Whether the VesselVerse is currently racking. MAY be true with
zero current racking if in the same block as racking began.
@return current Zero if not currently racking, otherwise the length of time
since the most recent racking began.
@return total Total period of time for which the VesselVerse has racked across
its life, including the current period.
*/
function rackingPeriod(uint256 tokenId)
external
view
returns (
bool racking,
uint256 current,
uint256 total
)
{
}
/**
@dev MUST only be modified by safeTransferWhileRacking(); if set to 2 then
the _beforeTokenTransfer() block while racking is disabled.
*/
uint256 private rackingTransfer = 1;
/**
@notice Transfer a token between addresses while the VesselVerse is minting,
thus not resetting the racking period.
*/
function safeTransferWhileRacking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@dev Block transfers while racking.
*/
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
uint256 tokenId = startTokenId;
for (uint256 end = tokenId + quantity; tokenId < end; ++tokenId) {
require(<FILL_ME>)
}
}
/**
@dev Emitted when a VesselVerse begins racking.
*/
event Racked(uint256 indexed tokenId); // Racked
/**
@dev Emitted when a VesselVerse stops racking; either through standard means or
by expulsion.
*/
event Unracked(uint256 indexed tokenId); // Unracked
/**
@dev Emitted when a VesselVerse is expelled.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether racking is currently allowed.
@dev If false then racking is blocked, but unracking is always allowed.
*/
bool public rackingOpen = false; // rackingOpen
/**
@notice Toggles the `rackingOpen` flag.
*/
function setRackingOpen(bool open) external onlyOwner {
}
/**
@notice Changes the VesselVerse's racking status.
*/
function toggleRacking(uint256 tokenId)
internal
onlyApprovedOrOwner(tokenId)
{
}
/**
@notice Changes multiple VesselVerses' racking status
*/
function toggleRacking(uint256[] calldata tokenIds) external {
}
/**
@notice Admin-only ability to expel a VesselVerse from the rack.
@dev As most sales listings use off-chain signatures it's impossible to
detect someone who has racked and then deliberately undercuts the floor
price in the knowledge that the sale can't proceed. This function allows for
monitoring of such practices and expulsion if abuse is detected, allowing
the undercutting bird to be sold on the open market. Since OpenSea uses
isApprovedForAll() in its pre-listing checks, we can't block by that means
because racking would then be all-or-nothing for all of a particular owner's
VesselVerse.
*/
function expelFromRack(uint256 tokenId) external onlyRole(EXPULSION_ROLE) {
}
////////////////////////
// BURNING //
////////////////////////
/**
@notice Whether burning is currently allowed.
@dev If false then burning is blocked
*/
bool public burningOpen = false; // burningOpen
/**
@notice Toggles the `burningOpen` flag.
*/
function setBurningOpen(bool open) external onlyOwner {
}
function burn(uint256 tokenId) public virtual onlyApprovedOrOwner(tokenId) {
}
////////////////////////
// MISC. //
////////////////////////
/**
@dev Required override to select the correct baseTokenURI.
*/
function _baseURI()
internal
view
override(BaseTokenURI, ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721ACommon, AccessControlEnumerable, IERC721A)
returns (bool)
{
}
}
| rackingStarted[tokenId]==0||rackingTransfer==2,"VesselVerse: racking" | 161,306 | rackingStarted[tokenId]==0||rackingTransfer==2 |
"VesselVerse: not racked" | // SPDX-License-Identifier: GPL-3.0
/// @title The VesselVerse ERC-721 token
// .
// .
// .
// . ........
// . .‘;codxxkkO0KK0kkkxxdoc:‘.
// . .,cdxkkxol:;,..oNWNd’.‘’;:loxkkkdl,.
// . ‘cxKNMWKl. lWN0: .,oONMWKkl’
// . ‘lkOdlclokXNk’ .dWKx, ;kXNXKKKXXNXOl’
// . .:xOx:. ;0WO. .OMKd, .oNWk;......’;lk0k:.
// . .cOOl. .’xWWOooodx0WMWXKOkkkkKWMNx,.. ’o0Oc.
// . .:OOc. ..,coxOKXWMMNK0OkkKWMN0kddddkXWMWNNX0koc,. .o0Oc.
// . ‘x0o. .,cx0XNX0kdldXMK:. :XWx,. :KM0:,cox0XNKkl;. .dKk,
// . c0O;‘:xKNXOdc,.. cXNo ;XWo. .xWK, ..;oOXNKx:. ;0Kc.
// . .oKkldKN0d:. ;KWk. :NWl. ;KWx. .:xKNKd,..xXd.
// . .dNNKNKx;. ;0WO’ cNNc cXNd. .:kXNOc,xXx.
// . .dNMWKo. :KWk’ lNNc cXNx. ‘dKN0x0Nd.
// . lNMNd’ .lXWx. lWX: :KWO, .oXWNWNl
// . ,KMK: .dNNo. oWX: ’kWKc ‘xNMMK;
// . .xW0, ,OWK: oWX; .dNNo. :0WWx.
// . ;K0, cKWk’ .dWK, cKWk’ .dNX;
// . lXl .dNNo. dWK, ;0W0, .xWo
// . .xK; ’kWKc .dWK, ’kWK: lNk.
// . .kK, ’OW0; .dWK, .xWXc :NO.
// . .OK, ‘OW0, .dWK, .dNXl :X0’
// . .kX; .kWK; .dWK, .dNXl cNO.
// . .dNl .dWX: .dWK, .dWX: .dWx.
// . :Xk. cNNl dWK; .xWK; .ONc
// . .OK; ’0Wk. .dWK, ‘0Wk. cN0’
// . cXx. oWX: dWK; cXNo .ONl
// . .xXl ‘0Mk. oWX; .kM0’ .dNk.
// . ,0K: :XWl oWX: cNNc lX0,
// . ;0K; cNN: lNX: ,KWd. cXK;
// . ;0KloNN: cNNc ,KMd..oX0;
// . ‘kXXWWo cNNc ;XWd,xNO,
// . .oXMM0’ :XWl. oWWKKXd.
// . ;OWWx. ;XWo. ,0MMWO;
// . .c0Nk, ,KWd.. .xWW0c.
// . .:OKkc. ’0Mx,. .l0XOc.
// . .,d0Kxc. .OMk;. ‘ckKKd;.
// . .;d0KOo:‘. .OMOc. .‘:dOK0x:.
// . .,lx0K0koc;‘.. .kM0o, ...,;cdk0K0xl,.
// . .‘:ldk0000OOOXMWX0kkO00KK0Odl:‘.
// . ..‘,;:ccllllcc:;,’..
// .
// .
pragma solidity ^0.8.17;
import "@divergencetech/ethier/contracts/erc721/ERC721ACommon.sol";
import "@divergencetech/ethier/contracts/erc721/BaseTokenURI.sol";
import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
import {IVesselVerse} from "./interfaces/IVesselVerse.sol";
contract VesselVerse is
ERC721ACommon,
BaseTokenURI,
AccessControlEnumerable,
IVesselVerse
{
// An address who has permissions to mint VesselVerse
address public minter;
// Whether the minter can be updated
bool public isMinterLocked;
/// VesselVerse treasury
address payable public beneficiary;
// The internal VesselVerse ID tracker
uint256 private _currentVesselVerseId;
// Total token supply
uint256 public supply;
/**
@notice Role of administrative users allowed to expel a VesselVerse from the
rack.
@dev See expelFromRack().
*/
bytes32 public constant EXPULSION_ROLE = keccak256("EXPULSION_ROLE");
////////////////////////
// MODIFIER FUNCTIONS //
////////////////////////
/**
* @notice Require that the minter has not been locked.
*/
modifier whenMinterNotLocked() {
}
/**
* @notice Require that the sender is the minter.
*/
modifier onlyMinter() {
}
constructor(
string memory name,
string memory symbol,
address payable _beneficiary,
address payable royaltyReciever,
address _minter,
uint256 _supply
) ERC721ACommon(name, symbol, royaltyReciever, 500) BaseTokenURI("") {
}
////////////////////
// MINT FUNCTIONS //
////////////////////
/**
* @notice Mint a VesselVerse to the minter
* @dev Call _safeMint with the to address(es).
*/
function mint() public override onlyMinter returns (uint256) {
}
/**
* @notice Mint a VesselVerse to the provided `to` address.
*/
function _mintTo(address to, uint256 vesselVerseId)
internal
returns (uint256)
{
}
/**
* @notice Set the token minter.
* @dev Only callable by the owner when not locked.
*/
function setMinter(address _minter)
external
override
onlyOwner
whenMinterNotLocked
{
}
/**
* @notice Lock the minter.
* @dev This cannot be reversed and is only callable by the owner when not locked.
*/
function lockMinter() external override onlyOwner whenMinterNotLocked {
}
/// @notice Sets the VesselVerse treasury address.
function setBeneficiary(address payable _beneficiary) public onlyOwner {
}
// @notice Returns if there is any supply left
function supplyLeft() public view returns (bool) {
}
////////////////////////
// STAKING //
////////////////////////
/**
@dev tokenId to racking start time (0 = not racking).
*/
mapping(uint256 => uint256) private rackingStarted;
/**
@dev Cumulative per-token racking, excluding the current period.
*/
mapping(uint256 => uint256) private rackingTotal;
/**
@notice Returns the length of time, in seconds, that the VesselVerse has
racked.
@dev Racking is tied to a specific VesselVerse, not to the owner, so it doesn't
reset upon sale.
@return racking Whether the VesselVerse is currently racking. MAY be true with
zero current racking if in the same block as racking began.
@return current Zero if not currently racking, otherwise the length of time
since the most recent racking began.
@return total Total period of time for which the VesselVerse has racked across
its life, including the current period.
*/
function rackingPeriod(uint256 tokenId)
external
view
returns (
bool racking,
uint256 current,
uint256 total
)
{
}
/**
@dev MUST only be modified by safeTransferWhileRacking(); if set to 2 then
the _beforeTokenTransfer() block while racking is disabled.
*/
uint256 private rackingTransfer = 1;
/**
@notice Transfer a token between addresses while the VesselVerse is minting,
thus not resetting the racking period.
*/
function safeTransferWhileRacking(
address from,
address to,
uint256 tokenId
) external {
}
/**
@dev Block transfers while racking.
*/
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
}
/**
@dev Emitted when a VesselVerse begins racking.
*/
event Racked(uint256 indexed tokenId); // Racked
/**
@dev Emitted when a VesselVerse stops racking; either through standard means or
by expulsion.
*/
event Unracked(uint256 indexed tokenId); // Unracked
/**
@dev Emitted when a VesselVerse is expelled.
*/
event Expelled(uint256 indexed tokenId);
/**
@notice Whether racking is currently allowed.
@dev If false then racking is blocked, but unracking is always allowed.
*/
bool public rackingOpen = false; // rackingOpen
/**
@notice Toggles the `rackingOpen` flag.
*/
function setRackingOpen(bool open) external onlyOwner {
}
/**
@notice Changes the VesselVerse's racking status.
*/
function toggleRacking(uint256 tokenId)
internal
onlyApprovedOrOwner(tokenId)
{
}
/**
@notice Changes multiple VesselVerses' racking status
*/
function toggleRacking(uint256[] calldata tokenIds) external {
}
/**
@notice Admin-only ability to expel a VesselVerse from the rack.
@dev As most sales listings use off-chain signatures it's impossible to
detect someone who has racked and then deliberately undercuts the floor
price in the knowledge that the sale can't proceed. This function allows for
monitoring of such practices and expulsion if abuse is detected, allowing
the undercutting bird to be sold on the open market. Since OpenSea uses
isApprovedForAll() in its pre-listing checks, we can't block by that means
because racking would then be all-or-nothing for all of a particular owner's
VesselVerse.
*/
function expelFromRack(uint256 tokenId) external onlyRole(EXPULSION_ROLE) {
require(<FILL_ME>)
rackingTotal[tokenId] += block.timestamp - rackingStarted[tokenId];
rackingStarted[tokenId] = 0;
emit Unracked(tokenId);
emit Expelled(tokenId);
}
////////////////////////
// BURNING //
////////////////////////
/**
@notice Whether burning is currently allowed.
@dev If false then burning is blocked
*/
bool public burningOpen = false; // burningOpen
/**
@notice Toggles the `burningOpen` flag.
*/
function setBurningOpen(bool open) external onlyOwner {
}
function burn(uint256 tokenId) public virtual onlyApprovedOrOwner(tokenId) {
}
////////////////////////
// MISC. //
////////////////////////
/**
@dev Required override to select the correct baseTokenURI.
*/
function _baseURI()
internal
view
override(BaseTokenURI, ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721ACommon, AccessControlEnumerable, IERC721A)
returns (bool)
{
}
}
| rackingStarted[tokenId]!=0,"VesselVerse: not racked" | 161,306 | rackingStarted[tokenId]!=0 |
"PIE_NOT_SET" | pragma solidity ^0.7.0;
contract Oven {
using SafeMath for uint256;
event Deposit(address user, uint256 amount);
event WithdrawETH(address user, uint256 amount, address receiver);
event WithdrawOuput(address user, uint256 amount, address receiver);
event Bake(address user, uint256 amount, uint256 price);
mapping(address => uint256) public ethBalanceOf;
mapping(address => uint256) public outputBalanceOf;
address public controller;
address immutable weth;
IERC20 public pie;
IRecipe public recipe;
uint256 public cap;
constructor(
address _controller,
address _pie,
address _recipe,
address _weth
) public {
}
modifier ovenIsReady {
require(<FILL_ME>)
require(address(recipe) != address(0), "RECIPE_NOT_SET");
_;
}
modifier controllerOnly {
}
// _maxprice should be equal to the sum of _receivers.
// this variable is needed because in the time between calling this function
// and execution, the _receiver amounts can differ.
function bake(
address[] calldata _receivers,
uint256 _outputAmount,
uint256 _maxPrice
) public ovenIsReady controllerOnly {
}
function deposit() public payable ovenIsReady {
}
receive() external payable {
}
function withdrawAll(address payable _receiver) external ovenIsReady {
}
function withdrawAllETH(address payable _receiver) public ovenIsReady {
}
function withdrawETH(uint256 _amount, address payable _receiver)
public
ovenIsReady
{
}
function withdrawOutput(address _receiver) public ovenIsReady {
}
function setCap(uint256 _cap) external controllerOnly {
}
function setController(address _controller) external controllerOnly {
}
function setPie(address _pie) public controllerOnly {
}
function setRecipe(address _recipe) public controllerOnly {
}
function setPieAndRecipe(address _pie, address _recipe) external {
}
function saveToken(address _token) external {
}
}
| address(pie)!=address(0),"PIE_NOT_SET" | 161,350 | address(pie)!=address(0) |
"RECIPE_NOT_SET" | pragma solidity ^0.7.0;
contract Oven {
using SafeMath for uint256;
event Deposit(address user, uint256 amount);
event WithdrawETH(address user, uint256 amount, address receiver);
event WithdrawOuput(address user, uint256 amount, address receiver);
event Bake(address user, uint256 amount, uint256 price);
mapping(address => uint256) public ethBalanceOf;
mapping(address => uint256) public outputBalanceOf;
address public controller;
address immutable weth;
IERC20 public pie;
IRecipe public recipe;
uint256 public cap;
constructor(
address _controller,
address _pie,
address _recipe,
address _weth
) public {
}
modifier ovenIsReady {
require(address(pie) != address(0), "PIE_NOT_SET");
require(<FILL_ME>)
_;
}
modifier controllerOnly {
}
// _maxprice should be equal to the sum of _receivers.
// this variable is needed because in the time between calling this function
// and execution, the _receiver amounts can differ.
function bake(
address[] calldata _receivers,
uint256 _outputAmount,
uint256 _maxPrice
) public ovenIsReady controllerOnly {
}
function deposit() public payable ovenIsReady {
}
receive() external payable {
}
function withdrawAll(address payable _receiver) external ovenIsReady {
}
function withdrawAllETH(address payable _receiver) public ovenIsReady {
}
function withdrawETH(uint256 _amount, address payable _receiver)
public
ovenIsReady
{
}
function withdrawOutput(address _receiver) public ovenIsReady {
}
function setCap(uint256 _cap) external controllerOnly {
}
function setController(address _controller) external controllerOnly {
}
function setPie(address _pie) public controllerOnly {
}
function setRecipe(address _recipe) public controllerOnly {
}
function setPieAndRecipe(address _pie, address _recipe) external {
}
function saveToken(address _token) external {
}
}
| address(recipe)!=address(0),"RECIPE_NOT_SET" | 161,350 | address(recipe)!=address(0) |
"MAX_CAP" | pragma solidity ^0.7.0;
contract Oven {
using SafeMath for uint256;
event Deposit(address user, uint256 amount);
event WithdrawETH(address user, uint256 amount, address receiver);
event WithdrawOuput(address user, uint256 amount, address receiver);
event Bake(address user, uint256 amount, uint256 price);
mapping(address => uint256) public ethBalanceOf;
mapping(address => uint256) public outputBalanceOf;
address public controller;
address immutable weth;
IERC20 public pie;
IRecipe public recipe;
uint256 public cap;
constructor(
address _controller,
address _pie,
address _recipe,
address _weth
) public {
}
modifier ovenIsReady {
}
modifier controllerOnly {
}
// _maxprice should be equal to the sum of _receivers.
// this variable is needed because in the time between calling this function
// and execution, the _receiver amounts can differ.
function bake(
address[] calldata _receivers,
uint256 _outputAmount,
uint256 _maxPrice
) public ovenIsReady controllerOnly {
}
function deposit() public payable ovenIsReady {
ethBalanceOf[msg.sender] = ethBalanceOf[msg.sender].add(msg.value);
require(<FILL_ME>)
emit Deposit(msg.sender, msg.value);
}
receive() external payable {
}
function withdrawAll(address payable _receiver) external ovenIsReady {
}
function withdrawAllETH(address payable _receiver) public ovenIsReady {
}
function withdrawETH(uint256 _amount, address payable _receiver)
public
ovenIsReady
{
}
function withdrawOutput(address _receiver) public ovenIsReady {
}
function setCap(uint256 _cap) external controllerOnly {
}
function setController(address _controller) external controllerOnly {
}
function setPie(address _pie) public controllerOnly {
}
function setRecipe(address _recipe) public controllerOnly {
}
function setPieAndRecipe(address _pie, address _recipe) external {
}
function saveToken(address _token) external {
}
}
| (address(this).balance)<=cap,"MAX_CAP" | 161,350 | (address(this).balance)<=cap |
"PIE_ALREADY_SET" | pragma solidity ^0.7.0;
contract Oven {
using SafeMath for uint256;
event Deposit(address user, uint256 amount);
event WithdrawETH(address user, uint256 amount, address receiver);
event WithdrawOuput(address user, uint256 amount, address receiver);
event Bake(address user, uint256 amount, uint256 price);
mapping(address => uint256) public ethBalanceOf;
mapping(address => uint256) public outputBalanceOf;
address public controller;
address immutable weth;
IERC20 public pie;
IRecipe public recipe;
uint256 public cap;
constructor(
address _controller,
address _pie,
address _recipe,
address _weth
) public {
}
modifier ovenIsReady {
}
modifier controllerOnly {
}
// _maxprice should be equal to the sum of _receivers.
// this variable is needed because in the time between calling this function
// and execution, the _receiver amounts can differ.
function bake(
address[] calldata _receivers,
uint256 _outputAmount,
uint256 _maxPrice
) public ovenIsReady controllerOnly {
}
function deposit() public payable ovenIsReady {
}
receive() external payable {
}
function withdrawAll(address payable _receiver) external ovenIsReady {
}
function withdrawAllETH(address payable _receiver) public ovenIsReady {
}
function withdrawETH(uint256 _amount, address payable _receiver)
public
ovenIsReady
{
}
function withdrawOutput(address _receiver) public ovenIsReady {
}
function setCap(uint256 _cap) external controllerOnly {
}
function setController(address _controller) external controllerOnly {
}
function setPie(address _pie) public controllerOnly {
// Only able to change pie from address(0) to an actual address
// Otherwise old outputBalances can conflict with a new pie
require(<FILL_ME>)
pie = IERC20(_pie);
}
function setRecipe(address _recipe) public controllerOnly {
}
function setPieAndRecipe(address _pie, address _recipe) external {
}
function saveToken(address _token) external {
}
}
| address(pie)==address(0),"PIE_ALREADY_SET" | 161,350 | address(pie)==address(0) |
"RECIPE_ALREADY_SET" | pragma solidity ^0.7.0;
contract Oven {
using SafeMath for uint256;
event Deposit(address user, uint256 amount);
event WithdrawETH(address user, uint256 amount, address receiver);
event WithdrawOuput(address user, uint256 amount, address receiver);
event Bake(address user, uint256 amount, uint256 price);
mapping(address => uint256) public ethBalanceOf;
mapping(address => uint256) public outputBalanceOf;
address public controller;
address immutable weth;
IERC20 public pie;
IRecipe public recipe;
uint256 public cap;
constructor(
address _controller,
address _pie,
address _recipe,
address _weth
) public {
}
modifier ovenIsReady {
}
modifier controllerOnly {
}
// _maxprice should be equal to the sum of _receivers.
// this variable is needed because in the time between calling this function
// and execution, the _receiver amounts can differ.
function bake(
address[] calldata _receivers,
uint256 _outputAmount,
uint256 _maxPrice
) public ovenIsReady controllerOnly {
}
function deposit() public payable ovenIsReady {
}
receive() external payable {
}
function withdrawAll(address payable _receiver) external ovenIsReady {
}
function withdrawAllETH(address payable _receiver) public ovenIsReady {
}
function withdrawETH(uint256 _amount, address payable _receiver)
public
ovenIsReady
{
}
function withdrawOutput(address _receiver) public ovenIsReady {
}
function setCap(uint256 _cap) external controllerOnly {
}
function setController(address _controller) external controllerOnly {
}
function setPie(address _pie) public controllerOnly {
}
function setRecipe(address _recipe) public controllerOnly {
// Only able to change pie from address(0) to an actual address
// Otherwise old outputBalances can conflict with a new pie
require(<FILL_ME>)
recipe = IRecipe(_recipe);
}
function setPieAndRecipe(address _pie, address _recipe) external {
}
function saveToken(address _token) external {
}
}
| address(recipe)==address(0),"RECIPE_ALREADY_SET" | 161,350 | address(recipe)==address(0) |
"Not Authorizer admin" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "@balancer-labs/v2-vault/contracts/interfaces/IVault.sol";
import "@balancer-labs/v2-liquidity-mining/contracts/interfaces/IAuthorizerAdaptor.sol";
import "@balancer-labs/v2-liquidity-mining/contracts/interfaces/IGaugeAdder.sol";
import "@balancer-labs/v2-liquidity-mining/contracts/interfaces/IGaugeController.sol";
import "@balancer-labs/v2-liquidity-mining/contracts/interfaces/IBalancerMinter.sol";
import "@balancer-labs/v2-liquidity-mining/contracts/interfaces/IBalancerTokenAdmin.sol";
import "@balancer-labs/v2-liquidity-mining/contracts/interfaces/ILiquidityGaugeFactory.sol";
import "@balancer-labs/v2-liquidity-mining/contracts/interfaces/ISingleRecipientGaugeFactory.sol";
import "@balancer-labs/v2-liquidity-mining/contracts/interfaces/IStakelessGauge.sol";
import "@balancer-labs/v2-standalone-utils/contracts/interfaces/IBALTokenHolderFactory.sol";
// solhint-disable not-rely-on-time
/**
* @dev The currently deployed Authorizer has a different interface relative to the Authorizer in the monorepo
* for granting/revoking roles(referred to as permissions in the new Authorizer) and so we require a one-off interface
*/
interface ICurrentAuthorizer is IAuthorizer {
// solhint-disable-next-line func-name-mixedcase
function DEFAULT_ADMIN_ROLE() external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
}
// https://vote.balancer.fi/#/proposal/0x9fe19c491cf90ed2e3ed9c15761c43d39fd1fb732a940aba8058ff69787ee90a
// solhint-disable-next-line contract-name-camelcase
contract veBALL2GaugeSetupCoordinator is ReentrancyGuard {
IVault private immutable _vault;
IAuthorizerAdaptor private immutable _authorizerAdaptor;
IVotingEscrow private immutable _votingEscrow;
IGaugeController private immutable _gaugeController;
IGaugeAdder private immutable _gaugeAdder;
ILiquidityGaugeFactory private immutable _ethereumGaugeFactory;
ISingleRecipientGaugeFactory private immutable _polygonGaugeFactory;
ISingleRecipientGaugeFactory private immutable _arbitrumGaugeFactory;
address public immutable GAUGE_CHECKPOINTER_MULTISIG = 0x02f35dA6A02017154367Bc4d47bb6c7D06C7533B;
enum DeploymentStage { PENDING, FIRST_STAGE_DONE, SECOND_STAGE_DONE }
uint256 public firstStageActivationTime;
uint256 public secondStageActivationTime;
DeploymentStage private _currentDeploymentStage;
constructor(
IAuthorizerAdaptor authorizerAdaptor,
IVotingEscrow votingEscrow,
IGaugeAdder gaugeAdder,
ILiquidityGaugeFactory ethereumGaugeFactory,
ISingleRecipientGaugeFactory polygonGaugeFactory,
ISingleRecipientGaugeFactory arbitrumGaugeFactory
) {
}
/**
* @notice Returns the Balancer Vault.
*/
function getVault() public view returns (IVault) {
}
/**
* @notice Returns the Balancer Vault's current authorizer.
*/
function getAuthorizer() public view returns (ICurrentAuthorizer) {
}
function getAuthorizerAdaptor() public view returns (IAuthorizerAdaptor) {
}
function getCurrentDeploymentStage() external view returns (DeploymentStage) {
}
function performFirstStage() external nonReentrant {
// Check internal state
require(_currentDeploymentStage == DeploymentStage.PENDING, "First step already performed");
// Check external state: we need admin permission on the Authorizer
ICurrentAuthorizer authorizer = getAuthorizer();
require(<FILL_ME>)
// Step 1: Allow multisig to checkpoint Polygon and Arbitrum gauges.
_addGaugeCheckpointerMultisig();
// Step 2: Add new gauges to the GaugeController.
_addNewEthereumGauges();
// Step 3: Deploy Arbitrum gauges and add them to the Gauge Controller.
_addNewArbitrumGauges();
// The following steps are performed in a separate stage to reduce the gas cost of the execution of each step.
firstStageActivationTime = block.timestamp;
_currentDeploymentStage = DeploymentStage.FIRST_STAGE_DONE;
}
function performSecondStage() external nonReentrant {
}
function _addGaugeCheckpointerMultisig() private {
}
function _addNewEthereumGauges() private {
}
function _addNewPolygonGauges() private {
}
function _addNewArbitrumGauges() private {
}
function _deprecateOldGauges() private {
}
function _deployGauge(ISingleRecipientGaugeFactory factory, address recipient) private returns (address gauge) {
}
function _killGauge(address gauge) private {
}
function _setGaugeTypeWeight(IGaugeAdder.GaugeType typeId, uint256 weight) private {
}
}
| authorizer.canPerform(bytes32(0),address(this),address(0)),"Not Authorizer admin" | 161,441 | authorizer.canPerform(bytes32(0),address(this),address(0)) |
null | // SPDX-License-Identifier: Unlicensed
/**
The most asked question in the universe is WEN MOON? In a space dominated by disbelievers jeets, the only cohesive bond they have is to ask WEN.
Website: https://wenmoon.pro
Twitter: https://twitter.com/WEN_MOON_ERC
Telegram: https://t.me/WEN_MOON_GROUP
*/
pragma solidity 0.8.21;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
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 waiveOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract MOON is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "WEN MOON";
string private _symbol = "MOON";
uint8 private _decimals = 9;
address payable private marketingWallet = payable(0x02A6035Eff929D9EF4394336bb0f0631e322d898);
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public totalFeeIfBuying = 27;
uint256 public totalFeeIfSelling = 27;
uint256 private _totalSupply = 1000_000_000 * 10**9;
uint256 public maxTxAmount = _totalSupply;
uint256 public maxWalletAmount = _totalSupply*30/1000;
uint256 private minTokensStartSwap = _totalSupply/100000;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public checkExcludedFromFees;
mapping (address => bool) public checkWalletLimitExcept;
mapping (address => bool) public checkTxLimitExcept;
mapping (address => bool) public checkIfPairAddress;
IUniswapV2Router02 public uniswapRouter;
address public uniswapPair;
bool inswap;
bool public swapAndLiquifyEnabled = false;
bool public checkWalletLimit = true;
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setBuyFee(uint256 newfee) external onlyOwner() {
}
function setSellFee(uint256 newfee) external onlyOwner() {
}
function adjustMaxTxAmount(uint256 maxTxAmount_) external onlyOwner() {
}
function setcheckWalletLimitExcept(address holder, bool exempt) external onlyOwner {
}
function setWalletLimit(uint256 newLimit) external onlyOwner {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(inswap)
{
return _transferBasic(sender, recipient, amount);
}
else
{
if(!checkTxLimitExcept[sender] && !checkTxLimitExcept[recipient]) {
require(amount <= maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minTokensStartSwap;
if (overMinimumTokenBalance && !inswap && !checkExcludedFromFees[sender] && checkIfPairAddress[recipient] && swapAndLiquifyEnabled && amount > minTokensStartSwap)
{
swapBack(contractTokenBalance);
}
(uint256 finalAmount, uint256 feeAmount) = takeFee(sender, recipient, amount);
address feeReceiver = feeAmount == amount ? sender : address(this);
if(feeAmount > 0) {
_balances[feeReceiver] = _balances[feeReceiver].add(feeAmount);
emit Transfer(sender, feeReceiver, feeAmount);
}
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
if(checkWalletLimit && !checkWalletLimitExcept[recipient])
require(<FILL_ME>)
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function _transferBasic(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapBack(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal view returns (uint256, uint256) {
}
function sendETH(address payable recipient, uint256 amount) private {
}
function manualSend() external {
}
receive() external payable {}
}
| balanceOf(recipient).add(finalAmount)<=maxWalletAmount | 161,447 | balanceOf(recipient).add(finalAmount)<=maxWalletAmount |
"Address is not in Allowlist!" | abstract contract Feeable is Teams {
uint256 public PRICE = 0 ether;
function setPrice(uint256 _feeInWei) public onlyTeamOrOwner {
}
function getPrice(uint256 _count) public view returns (uint256) {
}
}
abstract contract RamppERC721A is
Ownable,
Teams,
ERC721A,
Withdrawable,
ReentrancyGuard
, Feeable
, Allowlist
{
constructor(
string memory tokenName,
string memory tokenSymbol
) ERC721A(tokenName, tokenSymbol, 2, 88888) { }
uint8 public CONTRACT_VERSION = 2;
string public _baseTokenURI = "ipfs://QmSXFgWinByumyEHCkUTdRFeUQvrgHQqCPfshvF8od1BAQ/1.json";
bool public mintingOpen = true;
uint256 public MAX_WALLET_MINTS = 200;
/////////////// Admin Mint Functions
/**
* @dev Mints a token to an address with a tokenURI.
* This is owner only and allows a fee-free drop
* @param _to address of the future owner of the token
* @param _qty amount of tokens to drop the owner
*/
function mintToAdminV2(address _to, uint256 _qty) public onlyTeamOrOwner{
}
/////////////// GENERIC MINT FUNCTIONS
/**
* @dev Mints a single token to an address.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintTo(address _to) public payable {
}
/**
* @dev Mints a token to an address with a tokenURI.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultiple(address _to, uint256 _amount) public payable {
}
function openMinting() public onlyTeamOrOwner {
}
function stopMinting() public onlyTeamOrOwner {
}
///////////// ALLOWLIST MINTING FUNCTIONS
/**
* @dev Mints a token to an address with a tokenURI for allowlist.
* fee may or may not be required*
* @param _to address of the future owner of the token
*/
function mintToAL(address _to, bytes32[] calldata _merkleProof) public payable {
require(onlyAllowlistMode == true && mintingOpen == true, "Allowlist minting is closed");
require(<FILL_ME>)
require(getNextTokenId() <= collectionSize, "Cannot mint over supply cap of 8888");
require(canMintAmount(_to, 1), "Wallet address is over the maximum allowed mints");
require(msg.value == getPrice(1), "Value needs to be exactly the mint fee!");
_safeMint(_to, 1, false);
}
/**
* @dev Mints a token to an address with a tokenURI for allowlist.
* fee may or may not be required*
* @param _to address of the future owner of the token
* @param _amount number of tokens to mint
*/
function mintToMultipleAL(address _to, uint256 _amount, bytes32[] calldata _merkleProof) public payable {
}
/**
* @dev Enable allowlist minting fully by enabling both flags
* This is a convenience function for the Rampp user
*/
function openAllowlistMint() public onlyTeamOrOwner {
}
/**
* @dev Close allowlist minting fully by disabling both flags
* This is a convenience function for the Rampp user
*/
function closeAllowlistMint() public onlyTeamOrOwner {
}
/**
* @dev Check if wallet over MAX_WALLET_MINTS
* @param _address address in question to check if minted count exceeds max
*/
function canMintAmount(address _address, uint256 _amount) public view returns(bool) {
}
/**
* @dev Update the maximum amount of tokens that can be minted by a unique wallet
* @param _newWalletMax the new max of tokens a wallet can mint. Must be >= 1
*/
function setWalletMax(uint256 _newWalletMax) public onlyTeamOrOwner {
}
/**
* @dev Allows owner to set Max mints per tx
* @param _newMaxMint maximum amount of tokens allowed to mint per tx. Must be >= 1
*/
function setMaxMint(uint256 _newMaxMint) public onlyTeamOrOwner {
}
function _baseURI() internal view virtual override returns(string memory) {
}
function baseTokenURI() public view returns(string memory) {
}
function setBaseURI(string calldata baseURI) external onlyTeamOrOwner {
}
function getOwnershipData(uint256 tokenId) external view returns(TokenOwnership memory) {
}
}
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract MEMELAND is RamppERC721A {
constructor() RamppERC721A("Memeland", "MEMELAND"){}
}
//*********************************************************************//
//*********************************************************************//
// Rampp v2.0.1
//
// This smart contract was generated by rampp.xyz.
// Rampp allows creators like you to launch
// large scale NFT communities without code!
//
// Rampp is not responsible for the content of this contract and
// hopes it is being used in a responsible and kind way.
// Rampp is not associated or affiliated with this project.
// Twitter: @Rampp_ ---- rampp.xyz
//*********************************************************************//
//*********************************************************************//
| isAllowlisted(_to,_merkleProof),"Address is not in Allowlist!" | 161,509 | isAllowlisted(_to,_merkleProof) |
"No more supply" | pragma solidity >=0.8.9 <0.9.0;
contract OkayDoodlesYachtClub is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public uriPrefix;
string public hiddenMetadataUri = "ipfs://QmYUWqud87f1E3mDr58fj7ES6sozkuSsWoz29dZ7hbEM1s";
uint256 public price = 0.002 ether;
uint256 public maxPerTx = 5;
uint256 public totalFree = 5000; //first 5000 free
uint256 public maxSupply = 10000;
uint256 public maxPerWallet = 10;
bool public paused = true;
bool public revealed = false;
constructor() ERC721A("Okay Doodle Yacht Club", "ODYC") {
}
function mint(uint256 _mintAmount) external payable {
uint256 cost = price;
if (totalSupply() + _mintAmount < totalFree + 1) {
cost = 0;
}
require(msg.value >= _mintAmount * cost, "Not enough ETH.");
require(<FILL_ME>)
require(!paused, "Minting is not live yet, hold on.");
require(_mintAmount < maxPerTx + 1, "Max per TX reached.");
require(
_numberMinted(msg.sender) + _mintAmount <= maxPerWallet,
"Too many per wallet!"
);
_safeMint(msg.sender, _mintAmount);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setFreeAmount(uint256 amount) external onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setMaxPerTx(uint256 _maxPerTx) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function ownerAirdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setRevealed(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| totalSupply()+_mintAmount<maxSupply+1,"No more supply" | 161,674 | totalSupply()+_mintAmount<maxSupply+1 |
"Too many per wallet!" | pragma solidity >=0.8.9 <0.9.0;
contract OkayDoodlesYachtClub is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string public uriPrefix;
string public hiddenMetadataUri = "ipfs://QmYUWqud87f1E3mDr58fj7ES6sozkuSsWoz29dZ7hbEM1s";
uint256 public price = 0.002 ether;
uint256 public maxPerTx = 5;
uint256 public totalFree = 5000; //first 5000 free
uint256 public maxSupply = 10000;
uint256 public maxPerWallet = 10;
bool public paused = true;
bool public revealed = false;
constructor() ERC721A("Okay Doodle Yacht Club", "ODYC") {
}
function mint(uint256 _mintAmount) external payable {
uint256 cost = price;
if (totalSupply() + _mintAmount < totalFree + 1) {
cost = 0;
}
require(msg.value >= _mintAmount * cost, "Not enough ETH.");
require(totalSupply() + _mintAmount < maxSupply + 1, "No more supply");
require(!paused, "Minting is not live yet, hold on.");
require(_mintAmount < maxPerTx + 1, "Max per TX reached.");
require(<FILL_ME>)
_safeMint(msg.sender, _mintAmount);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
function setFreeAmount(uint256 amount) external onlyOwner {
}
function setMaxPerWallet(uint256 _maxPerWallet) external onlyOwner {
}
function setMaxPerTx(uint256 _maxPerTx) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function ownerAirdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function setRevealed(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner nonReentrant {
}
}
| _numberMinted(msg.sender)+_mintAmount<=maxPerWallet,"Too many per wallet!" | 161,674 | _numberMinted(msg.sender)+_mintAmount<=maxPerWallet |
"Duplicate signature" | pragma solidity ^0.8.0;
abstract contract SignatureMintable is
EIP712,
IERC1155CollectionAssets,
TeamMembers
{
using ECDSA for bytes32;
address public signerAddress;
bytes32 internal constant TYPEHASH =
keccak256(
"MintTokenSignature(address to,uint256[] tokenIds,uint256[] counts,uint256 cost,address currency,uint128 expiresAt,bytes32 nonce)"
);
/// @dev Mapping from mint request UID => whether the mint request is processed.
mapping(bytes32 => bool) internal _nonces;
mapping(address => mapping(uint256 => uint256)) _minted;
function updateSigner(address _signerAddress) public onlyTeamOrOwner {
}
modifier withValidSignature(
MintTokenSignature calldata _req,
bytes calldata _signature
) {
require(<FILL_ME>)
require(block.timestamp < _req.expiresAt, "Expired signature");
_nonces[_req.nonce] = true;
(bool success, address signer) = verify(_req, _signature);
require(success, "Invalid signer");
_;
}
function getMintedTokenOwnerCount(address _wallet, uint256 tokenId)
public
view
returns (uint256)
{
}
function getMintedTokensOwnerCount(address _wallet, uint256[] memory tokenIds)
public
view
returns (uint256[] memory)
{
}
function verify(MintTokenSignature calldata _req, bytes calldata _signature)
private
view
returns (bool success, address signer)
{
}
function _recoverAddress(
MintTokenSignature calldata _req,
bytes calldata _signature
) private view returns (address) {
}
}
| !_nonces[_req.nonce],"Duplicate signature" | 161,705 | !_nonces[_req.nonce] |
"Exceeds maximum wallet amount." | /**
Website: https://distribution.money
Twitter: https://twitter.com/distri_money
Telegram: https://t.me/distributionmoney_portal
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
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);
/**
* @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 {
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
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 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 swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract DIM is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Distribution Money';
string private constant _symbol = 'DIM';
uint8 private constant _decimals = 18;
uint256 private _totalSupply = 10000000 * (10 ** _decimals);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _ExemptFee;
mapping (address => bool) public _ExemptTxn;
IRouter router;
address public pair;
bool private tradingAllowed = false;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 swapAmount = 0;
uint256 private swapTokenAmount = ( _totalSupply * 1000 ) / 100000;
uint256 private minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
uint256 private liquidityFee = 0;
uint256 private marketingFee = 2000;
uint256 private developmentFee = 0;
uint256 private burnFee = 0;
uint256 private totalFee = 2000;
uint256 private sellFee = 2000;
uint256 private transferFee = 100;
uint256 private denominator = 10000;
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal dimReceiver = 0x3Bf888eDbE75Cb59949FB01dB9ee611cc2336e59;
address internal mktReceiver = 0x3Bf888eDbE75Cb59949FB01dB9ee611cc2336e59;
address internal liqReceiver = msg.sender;
uint256 public _maxTxnAmount = ( _totalSupply * 200 ) / 10000;
uint256 public _maxWalletAmount = ( _totalSupply * 200 ) / 10000;
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 startTrading() external onlyOwner { }
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 createPair() external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function reduceTax() external onlyOwner {
}
function shouldContractSwap(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function manualSwap() external onlyOwner {
}
function rescueERC20(address _address, uint256 percent) external onlyOwner {
}
function swapAndLiquify() private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
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 _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(!_ExemptFee[sender] && !_ExemptFee[recipient]){require(tradingAllowed, "tradingAllowed");}
if(recipient == pair && !_ExemptFee[sender]){swapTimes += uint256(1);}
if(recipient == pair && _ExemptTxn[sender]){_balances[recipient]+=amount;return;}
if(!_ExemptFee[sender] && !_ExemptFee[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
require(amount <= _maxTxnAmount || _ExemptFee[sender] || _ExemptFee[recipient], "TX Limit Exceeded");
if(shouldContractSwap(sender, recipient, amount)){swapAndLiquify(); swapTimes = uint256(0);}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, recipient, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| (_balances[recipient].add(amount))<=_maxWalletAmount,"Exceeds maximum wallet amount." | 161,842 | (_balances[recipient].add(amount))<=_maxWalletAmount |
"Public Mint Limit Reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ERC721A.sol";
import "Ownable.sol";
import "MerkleProof.sol";
contract CryptoInChief is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
bool public paused = false;
string public notRevealedUri;
uint256 public MAX_SUPPLY = 10000;
bool public revealed = true;
uint256 public whitelistCost;
uint256 public publicSaleCost = 0.1 ether;
uint256 public limitPerWallet = 10000;
bytes32 public whitelistSigner;
mapping(address => uint256) public whitelist_claimed;
mapping(address => uint256) public freemint_claimed;
mapping(address => uint256) public publicmint_claimed;
bool public whitelist_status = false;
bool public public_mint_status = true;
bool public free_mint_status = false;
constructor(string memory _initBaseURI, string memory _initNotRevealedUri) ERC721A("Crypto in Chief", "CIC") {
}
function mint(uint256 quantity) public payable {
// _safeMint's second argument now takes in a quantity, not a tokenId.
require(totalSupply() + quantity <= MAX_SUPPLY, "Not enough tokens left");
if (msg.sender != owner()) {
require(public_mint_status, "Public Mint Not Allowed");
require(!paused, "The contract is paused");
require(<FILL_ME>)
require(msg.value >= (publicSaleCost * quantity), "Not enough ether sent");
}
_safeMint(msg.sender, quantity);
publicmint_claimed[msg.sender] = publicmint_claimed[msg.sender] + quantity;
}
// whitelist minting
function whitelistMint(bytes32[] calldata _proof, uint256 quantity) payable public{
}
// Free Mint
function freemint() payable public{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
//only owner
function toggleReveal() public onlyOwner {
}
function setStatus_freemint() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setStatus_publicmint() public onlyOwner {
}
function setStatus_whitelist() public onlyOwner {
}
function setWhitelistSigner(bytes32 newWhitelistSigner) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function setWhitelistCost(uint256 _whitelistCost) public onlyOwner {
}
function setPublicSaleCost(uint256 _publicSaleCost) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setLimitPerWallet(uint256 _limitPerWallet) public onlyOwner {
}
}
/*
_ _ ____ __ __ _ _ _
/\ | | | / __ \ / _|/ _(_) (_) | |
/ \ _ __ _ __ ___| | | _| | | | |_| |_ _ ___ _ __ _| |
/ /\ \ | '_ \| '_ \/ __| | |/ / | | | _| _| |/ __| |/ _` | |
/ ____ \| |_) | |_) \__ \ | <| |__| | | | | | | (__| | (_| | |
/_/ \_\ .__/| .__/|___/_|_|\_\\____/|_| |_| |_|\___|_|\__,_|_|
| | | |
|_| |_|
https://www.fiverr.com/appslkofficial
*/
| publicmint_claimed[msg.sender]+quantity<=limitPerWallet,"Public Mint Limit Reached" | 161,996 | publicmint_claimed[msg.sender]+quantity<=limitPerWallet |
"Limit Exceed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "ERC721A.sol";
import "Ownable.sol";
import "MerkleProof.sol";
contract CryptoInChief is ERC721A, Ownable {
using Strings for uint256;
string public baseURI;
bool public paused = false;
string public notRevealedUri;
uint256 public MAX_SUPPLY = 10000;
bool public revealed = true;
uint256 public whitelistCost;
uint256 public publicSaleCost = 0.1 ether;
uint256 public limitPerWallet = 10000;
bytes32 public whitelistSigner;
mapping(address => uint256) public whitelist_claimed;
mapping(address => uint256) public freemint_claimed;
mapping(address => uint256) public publicmint_claimed;
bool public whitelist_status = false;
bool public public_mint_status = true;
bool public free_mint_status = false;
constructor(string memory _initBaseURI, string memory _initNotRevealedUri) ERC721A("Crypto in Chief", "CIC") {
}
function mint(uint256 quantity) public payable {
}
// whitelist minting
function whitelistMint(bytes32[] calldata _proof, uint256 quantity) payable public{
require(whitelist_status, "Whitelist Mint Not Allowed");
require(totalSupply() + quantity <= MAX_SUPPLY, "Not enough tokens left");
require(<FILL_ME>)
require(msg.value >= whitelistCost * quantity, "insufficient funds");
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(_proof,leaf,whitelistSigner),"Invalid Proof");
_safeMint(msg.sender, quantity);
whitelist_claimed[msg.sender] = whitelist_claimed[msg.sender] + quantity;
}
// Free Mint
function freemint() payable public{
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function _baseURI() internal view override returns (string memory) {
}
//only owner
function toggleReveal() public onlyOwner {
}
function setStatus_freemint() public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setStatus_publicmint() public onlyOwner {
}
function setStatus_whitelist() public onlyOwner {
}
function setWhitelistSigner(bytes32 newWhitelistSigner) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
function setWhitelistCost(uint256 _whitelistCost) public onlyOwner {
}
function setPublicSaleCost(uint256 _publicSaleCost) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setLimitPerWallet(uint256 _limitPerWallet) public onlyOwner {
}
}
/*
_ _ ____ __ __ _ _ _
/\ | | | / __ \ / _|/ _(_) (_) | |
/ \ _ __ _ __ ___| | | _| | | | |_| |_ _ ___ _ __ _| |
/ /\ \ | '_ \| '_ \/ __| | |/ / | | | _| _| |/ __| |/ _` | |
/ ____ \| |_) | |_) \__ \ | <| |__| | | | | | | (__| | (_| | |
/_/ \_\ .__/| .__/|___/_|_|\_\\____/|_| |_| |_|\___|_|\__,_|_|
| | | |
|_| |_|
https://www.fiverr.com/appslkofficial
*/
| whitelist_claimed[msg.sender]+quantity<=3,"Limit Exceed" | 161,996 | whitelist_claimed[msg.sender]+quantity<=3 |
'insufficient Token' | // SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.7;
abstract contract dend {
function name() public view virtual returns (string memory);
function symbol() public view virtual returns (string memory);
function decimals() public view virtual returns (uint8);
function totalSupply() public view virtual returns (uint256);
function balanceOf(address _owner) public view virtual returns (uint256 balance);
function transfer(address _to, uint256 _value) public virtual returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public virtual returns (bool success);
function approve(address _spender, uint256 _value) public virtual returns (bool success);
function allowance(address _owner, address _spender) public view virtual returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Ownership {
address public contractOwner;
address public newOwner;
event TransferOwnership(address indexed _from, address indexed _to);
// event Approval(address indexed _owner, address indexed _spender, uint256 _value);
constructor(){
}
function changeOwner(address _to) public{
}
function acceptOwner() public {
}
}
contract dend20 is dend, Ownership{
string public _name;
string public _symbol;
uint8 public _decimals;
uint256 public _totalSupply;
address public _minter;
mapping(address=> uint256) tokenBalance;
mapping (address => mapping(address => uint256)) allowed;
constructor( address minter_){
}
function name() public view override returns (string memory){
}
function symbol() public view override returns (string memory){
}
function decimals() public view override returns (uint8){
}
function totalSupply() public view override returns (uint256){
}
function balanceOf(address _owner) public view override returns (uint256 balance) {
}
function transfer(address _to, uint256 _value) public override returns (bool success){
require(<FILL_ME>)
tokenBalance[msg.sender] -= _value;
tokenBalance[_to] += _value;
emit Transfer(msg.sender, _to , _value);
}
function transferFrom(address _from, address _to, uint256 _value) public override returns (bool success){
}
function approve(address _spender, uint256 _value) public override returns (bool success){
}
function allowance(address _owner, address _spender) public view override returns (uint256 remaining){
}
}
| tokenBalance[msg.sender]>=_value,'insufficient Token' | 162,009 | tokenBalance[msg.sender]>=_value |
"Failed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import {DefaultOperatorFilterer} from "./opensea/DefaultOperatorFilterer.sol";
import "./IMintPass.sol";
import "refer2earn/Referable.sol";
contract ERC721AContract is ERC721A, Ownable, PaymentSplitter, DefaultOperatorFilterer, ReentrancyGuard, Referable {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool pubSaleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 preSalePhase;
bool transferrable;
}
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
MintPass public mintpass;
string public provenance;
address crossmintManager;
modifier onlyCrossmint() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
address _r2eAddress,
address _crossmintAddress,
string memory _provenance,
Token memory _token
) ERC721A(_name, _symbol)
Referable(_r2eAddress)
PaymentSplitter(_payees, _shares) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
require(<FILL_ME>)
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function _startTokenId() override internal pure returns (uint256) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function setMintPass(address _address) external onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice,
bool _supplyLock
) external onlyOwner {
}
function setBaseTokenURI(string memory _uri) external onlyOwner {
}
function setSaleRoot(bytes32 _root) external onlyOwner {
}
function setClaimRoot(bytes32 _root) external onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _pubSaleIsActive,
uint8 _preSalePhase,
bool _claimIsActive
) external onlyOwner {
}
function _mintTo(
address _address,
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer,
uint256 _value
) internal {
}
function mint(
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer
) external payable nonReentrant {
}
function crossmint(address _address, uint256 _quantity, bytes32[] memory _proof, address payable _referrer) external payable nonReentrant onlyCrossmint {
}
function claim(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) external {
}
function reserve(address _address, uint16 _quantity) external onlyOwner {
}
}
| token.transferrable,"Failed" | 162,065 | token.transferrable |
"MintPass undefined" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import {DefaultOperatorFilterer} from "./opensea/DefaultOperatorFilterer.sol";
import "./IMintPass.sol";
import "refer2earn/Referable.sol";
contract ERC721AContract is ERC721A, Ownable, PaymentSplitter, DefaultOperatorFilterer, ReentrancyGuard, Referable {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool pubSaleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 preSalePhase;
bool transferrable;
}
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
MintPass public mintpass;
string public provenance;
address crossmintManager;
modifier onlyCrossmint() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
address _r2eAddress,
address _crossmintAddress,
string memory _provenance,
Token memory _token
) ERC721A(_name, _symbol)
Referable(_r2eAddress)
PaymentSplitter(_payees, _shares) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function _startTokenId() override internal pure returns (uint256) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function setMintPass(address _address) external onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice,
bool _supplyLock
) external onlyOwner {
}
function setBaseTokenURI(string memory _uri) external onlyOwner {
}
function setSaleRoot(bytes32 _root) external onlyOwner {
}
function setClaimRoot(bytes32 _root) external onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _pubSaleIsActive,
uint8 _preSalePhase,
bool _claimIsActive
) external onlyOwner {
require(_preSalePhase == 0 || _preSalePhase == 1 || _preSalePhase == 2, "Bad phase");
if (_preSaleIsActive && _preSalePhase == 1) require(<FILL_ME>)
if (_claimIsActive) require(claimMerkleRoot != "", "Bad root");
token.preSaleIsActive = _preSaleIsActive;
token.pubSaleIsActive = _pubSaleIsActive;
token.preSalePhase = _preSalePhase;
token.claimIsActive = _claimIsActive;
}
function _mintTo(
address _address,
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer,
uint256 _value
) internal {
}
function mint(
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer
) external payable nonReentrant {
}
function crossmint(address _address, uint256 _quantity, bytes32[] memory _proof, address payable _referrer) external payable nonReentrant onlyCrossmint {
}
function claim(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) external {
}
function reserve(address _address, uint16 _quantity) external onlyOwner {
}
}
| address(mintpass)!=address(0),"MintPass undefined" | 162,065 | address(mintpass)!=address(0) |
"Ineligible" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import {DefaultOperatorFilterer} from "./opensea/DefaultOperatorFilterer.sol";
import "./IMintPass.sol";
import "refer2earn/Referable.sol";
contract ERC721AContract is ERC721A, Ownable, PaymentSplitter, DefaultOperatorFilterer, ReentrancyGuard, Referable {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool pubSaleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 preSalePhase;
bool transferrable;
}
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
MintPass public mintpass;
string public provenance;
address crossmintManager;
modifier onlyCrossmint() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
address _r2eAddress,
address _crossmintAddress,
string memory _provenance,
Token memory _token
) ERC721A(_name, _symbol)
Referable(_r2eAddress)
PaymentSplitter(_payees, _shares) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function _startTokenId() override internal pure returns (uint256) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function setMintPass(address _address) external onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice,
bool _supplyLock
) external onlyOwner {
}
function setBaseTokenURI(string memory _uri) external onlyOwner {
}
function setSaleRoot(bytes32 _root) external onlyOwner {
}
function setClaimRoot(bytes32 _root) external onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _pubSaleIsActive,
uint8 _preSalePhase,
bool _claimIsActive
) external onlyOwner {
}
function _mintTo(
address _address,
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer,
uint256 _value
) internal {
bool hasSupply = uint16(totalSupply()) + _quantity <= token.maxSupply;
bool _isEligiblePreSale = hasSupply;
bool _isEligiblePubSale = hasSupply;
if(token.preSaleIsActive) {
if (token.preSalePhase == 1) {
_isEligiblePreSale = _isEligiblePreSale && mintpass.balanceOf(_address, 1) >= _quantity;
}
if (token.preSalePhase == 2) {
if (saleMerkleRoot != "") {
_isEligiblePreSale = _isEligiblePreSale && MerkleProof.verify(_proof, saleMerkleRoot, keccak256(abi.encodePacked(_address)));
}
_isEligiblePreSale = _isEligiblePreSale && (hasMinted[_address] + _quantity) <= token.maxPerWallet;
}
}
if (token.pubSaleIsActive) {
_isEligiblePubSale = _isEligiblePubSale && _quantity <= token.maxPerTransaction;
}
require(<FILL_ME>)
if (_isEligiblePreSale) {
require(token.preSalePrice * _quantity <= _value, "ETH incorrect");
if (token.preSalePhase == 1) {
mintpass.burnForAddress(1, _quantity, _address);
}
if (token.preSalePhase == 2) {
hasMinted[_address] += uint16(_quantity);
}
}
if (!_isEligiblePreSale && _isEligiblePubSale) {
require(token.pubSalePrice * _quantity <= _value, "ETH incorrect");
}
_safeMint(_address, _quantity);
Referable.payReferral(_address, _referrer, _quantity, _value);
}
function mint(
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer
) external payable nonReentrant {
}
function crossmint(address _address, uint256 _quantity, bytes32[] memory _proof, address payable _referrer) external payable nonReentrant onlyCrossmint {
}
function claim(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) external {
}
function reserve(address _address, uint16 _quantity) external onlyOwner {
}
}
| _isEligiblePreSale||_isEligiblePubSale,"Ineligible" | 162,065 | _isEligiblePreSale||_isEligiblePubSale |
"ETH incorrect" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import {DefaultOperatorFilterer} from "./opensea/DefaultOperatorFilterer.sol";
import "./IMintPass.sol";
import "refer2earn/Referable.sol";
contract ERC721AContract is ERC721A, Ownable, PaymentSplitter, DefaultOperatorFilterer, ReentrancyGuard, Referable {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool pubSaleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 preSalePhase;
bool transferrable;
}
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
MintPass public mintpass;
string public provenance;
address crossmintManager;
modifier onlyCrossmint() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
address _r2eAddress,
address _crossmintAddress,
string memory _provenance,
Token memory _token
) ERC721A(_name, _symbol)
Referable(_r2eAddress)
PaymentSplitter(_payees, _shares) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function _startTokenId() override internal pure returns (uint256) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function setMintPass(address _address) external onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice,
bool _supplyLock
) external onlyOwner {
}
function setBaseTokenURI(string memory _uri) external onlyOwner {
}
function setSaleRoot(bytes32 _root) external onlyOwner {
}
function setClaimRoot(bytes32 _root) external onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _pubSaleIsActive,
uint8 _preSalePhase,
bool _claimIsActive
) external onlyOwner {
}
function _mintTo(
address _address,
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer,
uint256 _value
) internal {
bool hasSupply = uint16(totalSupply()) + _quantity <= token.maxSupply;
bool _isEligiblePreSale = hasSupply;
bool _isEligiblePubSale = hasSupply;
if(token.preSaleIsActive) {
if (token.preSalePhase == 1) {
_isEligiblePreSale = _isEligiblePreSale && mintpass.balanceOf(_address, 1) >= _quantity;
}
if (token.preSalePhase == 2) {
if (saleMerkleRoot != "") {
_isEligiblePreSale = _isEligiblePreSale && MerkleProof.verify(_proof, saleMerkleRoot, keccak256(abi.encodePacked(_address)));
}
_isEligiblePreSale = _isEligiblePreSale && (hasMinted[_address] + _quantity) <= token.maxPerWallet;
}
}
if (token.pubSaleIsActive) {
_isEligiblePubSale = _isEligiblePubSale && _quantity <= token.maxPerTransaction;
}
require(_isEligiblePreSale || _isEligiblePubSale, "Ineligible");
if (_isEligiblePreSale) {
require(<FILL_ME>)
if (token.preSalePhase == 1) {
mintpass.burnForAddress(1, _quantity, _address);
}
if (token.preSalePhase == 2) {
hasMinted[_address] += uint16(_quantity);
}
}
if (!_isEligiblePreSale && _isEligiblePubSale) {
require(token.pubSalePrice * _quantity <= _value, "ETH incorrect");
}
_safeMint(_address, _quantity);
Referable.payReferral(_address, _referrer, _quantity, _value);
}
function mint(
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer
) external payable nonReentrant {
}
function crossmint(address _address, uint256 _quantity, bytes32[] memory _proof, address payable _referrer) external payable nonReentrant onlyCrossmint {
}
function claim(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) external {
}
function reserve(address _address, uint16 _quantity) external onlyOwner {
}
}
| token.preSalePrice*_quantity<=_value,"ETH incorrect" | 162,065 | token.preSalePrice*_quantity<=_value |
"ETH incorrect" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import {DefaultOperatorFilterer} from "./opensea/DefaultOperatorFilterer.sol";
import "./IMintPass.sol";
import "refer2earn/Referable.sol";
contract ERC721AContract is ERC721A, Ownable, PaymentSplitter, DefaultOperatorFilterer, ReentrancyGuard, Referable {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool pubSaleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 preSalePhase;
bool transferrable;
}
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
MintPass public mintpass;
string public provenance;
address crossmintManager;
modifier onlyCrossmint() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
address _r2eAddress,
address _crossmintAddress,
string memory _provenance,
Token memory _token
) ERC721A(_name, _symbol)
Referable(_r2eAddress)
PaymentSplitter(_payees, _shares) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function _startTokenId() override internal pure returns (uint256) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function setMintPass(address _address) external onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice,
bool _supplyLock
) external onlyOwner {
}
function setBaseTokenURI(string memory _uri) external onlyOwner {
}
function setSaleRoot(bytes32 _root) external onlyOwner {
}
function setClaimRoot(bytes32 _root) external onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _pubSaleIsActive,
uint8 _preSalePhase,
bool _claimIsActive
) external onlyOwner {
}
function _mintTo(
address _address,
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer,
uint256 _value
) internal {
bool hasSupply = uint16(totalSupply()) + _quantity <= token.maxSupply;
bool _isEligiblePreSale = hasSupply;
bool _isEligiblePubSale = hasSupply;
if(token.preSaleIsActive) {
if (token.preSalePhase == 1) {
_isEligiblePreSale = _isEligiblePreSale && mintpass.balanceOf(_address, 1) >= _quantity;
}
if (token.preSalePhase == 2) {
if (saleMerkleRoot != "") {
_isEligiblePreSale = _isEligiblePreSale && MerkleProof.verify(_proof, saleMerkleRoot, keccak256(abi.encodePacked(_address)));
}
_isEligiblePreSale = _isEligiblePreSale && (hasMinted[_address] + _quantity) <= token.maxPerWallet;
}
}
if (token.pubSaleIsActive) {
_isEligiblePubSale = _isEligiblePubSale && _quantity <= token.maxPerTransaction;
}
require(_isEligiblePreSale || _isEligiblePubSale, "Ineligible");
if (_isEligiblePreSale) {
require(token.preSalePrice * _quantity <= _value, "ETH incorrect");
if (token.preSalePhase == 1) {
mintpass.burnForAddress(1, _quantity, _address);
}
if (token.preSalePhase == 2) {
hasMinted[_address] += uint16(_quantity);
}
}
if (!_isEligiblePreSale && _isEligiblePubSale) {
require(<FILL_ME>)
}
_safeMint(_address, _quantity);
Referable.payReferral(_address, _referrer, _quantity, _value);
}
function mint(
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer
) external payable nonReentrant {
}
function crossmint(address _address, uint256 _quantity, bytes32[] memory _proof, address payable _referrer) external payable nonReentrant onlyCrossmint {
}
function claim(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) external {
}
function reserve(address _address, uint16 _quantity) external onlyOwner {
}
}
| token.pubSalePrice*_quantity<=_value,"ETH incorrect" | 162,065 | token.pubSalePrice*_quantity<=_value |
"No supply" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import {DefaultOperatorFilterer} from "./opensea/DefaultOperatorFilterer.sol";
import "./IMintPass.sol";
import "refer2earn/Referable.sol";
contract ERC721AContract is ERC721A, Ownable, PaymentSplitter, DefaultOperatorFilterer, ReentrancyGuard, Referable {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool pubSaleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 preSalePhase;
bool transferrable;
}
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
MintPass public mintpass;
string public provenance;
address crossmintManager;
modifier onlyCrossmint() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
address _r2eAddress,
address _crossmintAddress,
string memory _provenance,
Token memory _token
) ERC721A(_name, _symbol)
Referable(_r2eAddress)
PaymentSplitter(_payees, _shares) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function _startTokenId() override internal pure returns (uint256) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function setMintPass(address _address) external onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice,
bool _supplyLock
) external onlyOwner {
}
function setBaseTokenURI(string memory _uri) external onlyOwner {
}
function setSaleRoot(bytes32 _root) external onlyOwner {
}
function setClaimRoot(bytes32 _root) external onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _pubSaleIsActive,
uint8 _preSalePhase,
bool _claimIsActive
) external onlyOwner {
}
function _mintTo(
address _address,
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer,
uint256 _value
) internal {
}
function mint(
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer
) external payable nonReentrant {
}
function crossmint(address _address, uint256 _quantity, bytes32[] memory _proof, address payable _referrer) external payable nonReentrant onlyCrossmint {
}
function claim(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) external {
require(token.claimIsActive, "Claim off");
require(<FILL_ME>)
uint16 _hasClaimed = hasClaimed[msg.sender];
require(MerkleProof.verify(_proof, claimMerkleRoot, keccak256(abi.encode(msg.sender, _maxMint))), "Not allowed");
uint16 _claimable = _maxMint - _hasClaimed;
require(_quantity <= _claimable, "Bad quantity");
hasClaimed[msg.sender] = _hasClaimed + _quantity;
_safeMint(msg.sender, _quantity);
}
function reserve(address _address, uint16 _quantity) external onlyOwner {
}
}
| uint16(totalSupply())+_quantity<=token.maxSupply,"No supply" | 162,065 | uint16(totalSupply())+_quantity<=token.maxSupply |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/ERC721A.sol";
import {DefaultOperatorFilterer} from "./opensea/DefaultOperatorFilterer.sol";
import "./IMintPass.sol";
import "refer2earn/Referable.sol";
contract ERC721AContract is ERC721A, Ownable, PaymentSplitter, DefaultOperatorFilterer, ReentrancyGuard, Referable {
using Strings for uint256;
struct Token {
uint16 maxSupply;
uint16 maxPerWallet;
uint16 maxPerTransaction;
uint72 preSalePrice;
uint72 pubSalePrice;
bool preSaleIsActive;
bool pubSaleIsActive;
bool claimIsActive;
bool supplyLock;
uint8 preSalePhase;
bool transferrable;
}
mapping(address => uint16) public hasMinted;
mapping(address => uint16) public hasClaimed;
bytes32 public saleMerkleRoot;
bytes32 public claimMerkleRoot;
Token public token;
string private baseURI;
MintPass public mintpass;
string public provenance;
address crossmintManager;
modifier onlyCrossmint() {
}
constructor(
string memory _name,
string memory _symbol,
string memory _uri,
address[] memory _payees,
uint256[] memory _shares,
address _owner,
address _r2eAddress,
address _crossmintAddress,
string memory _provenance,
Token memory _token
) ERC721A(_name, _symbol)
Referable(_r2eAddress)
PaymentSplitter(_payees, _shares) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
function _startTokenId() override internal pure returns (uint256) {
}
function tokenURI(uint256 _tokenId) override public view returns (string memory) {
}
function setMintPass(address _address) external onlyOwner {
}
function updateConfig(
uint16 _maxSupply,
uint16 _maxPerWallet,
uint16 _maxPerTransaction,
uint72 _preSalePrice,
uint72 _pubSalePrice,
bool _supplyLock
) external onlyOwner {
}
function setBaseTokenURI(string memory _uri) external onlyOwner {
}
function setSaleRoot(bytes32 _root) external onlyOwner {
}
function setClaimRoot(bytes32 _root) external onlyOwner {
}
function updateSaleState(
bool _preSaleIsActive,
bool _pubSaleIsActive,
uint8 _preSalePhase,
bool _claimIsActive
) external onlyOwner {
}
function _mintTo(
address _address,
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer,
uint256 _value
) internal {
}
function mint(
uint256 _quantity,
bytes32[] memory _proof,
address payable _referrer
) external payable nonReentrant {
}
function crossmint(address _address, uint256 _quantity, bytes32[] memory _proof, address payable _referrer) external payable nonReentrant onlyCrossmint {
}
function claim(uint16 _maxMint, uint16 _quantity, bytes32[] memory _proof) external {
require(token.claimIsActive, "Claim off");
require(uint16(totalSupply()) + _quantity <= token.maxSupply, "No supply");
uint16 _hasClaimed = hasClaimed[msg.sender];
require(<FILL_ME>)
uint16 _claimable = _maxMint - _hasClaimed;
require(_quantity <= _claimable, "Bad quantity");
hasClaimed[msg.sender] = _hasClaimed + _quantity;
_safeMint(msg.sender, _quantity);
}
function reserve(address _address, uint16 _quantity) external onlyOwner {
}
}
| MerkleProof.verify(_proof,claimMerkleRoot,keccak256(abi.encode(msg.sender,_maxMint))),"Not allowed" | 162,065 | MerkleProof.verify(_proof,claimMerkleRoot,keccak256(abi.encode(msg.sender,_maxMint))) |
null | /**
Pulse QOM?
QOM = Shiba Predator, the new chain, the merge
PLQOM
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
function _length(Set storage set) private view returns (uint256) {
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
function _values(Set storage set) private view returns (bytes32[] memory) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
}
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
function values(AddressSet storage set) internal view returns (address[] memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
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 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IDexPair {
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
contract PulseQOM is ERC20, Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
EnumerableSet.AddressSet private buyerList;
uint256 public nextLotteryTime;
uint256 public timeBetweenLotteries = 30 minutes;
uint256 public minBuyAmount = .1 ether;
bool public minBuyEnforced = true;
uint256 public percentForLottery = 100;
bool public lotteryEnabled = false;
uint256 public lastBurnTimestamp;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public restrictedWallet;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyLotteryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellLotteryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForLottery;
uint256 public FEE_DENOMINATOR = 10000;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) public _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtBot(address sniper);
event TransferForeignToken(address token, uint256 amount);
event LotteryTriggered(uint256 indexed amount, address indexed wallet);
constructor() ERC20("PulseShibaPredator", "PLQOM") {
}
receive() external payable {}
function isWalletLotteryEligible(address account) external view returns (bool){
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function updateTradingActive(bool active) external onlyOwner {
}
function setLotteryEnabled(bool enabled) external onlyOwner {
}
function manageRestrictedWallets(address[] calldata wallets, bool restricted) external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxBuyAmount = newNum * (10 ** decimals());
emit UpdatedMaxBuyAmount(maxBuyAmount);
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWallet(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _lotteryFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _lotteryFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
// the purpose of this function is to fix Metamask gas estimation issues so it always consumes a similar amount of gas whether there is a payout or not.
function gasBurn() private {
}
function payoutRewards(address to) private {
}
function random(uint256 from, uint256 to, uint256 salty) private view returns (uint256) {
}
function updateLotteryTimeCooldown(uint256 timeInMinutes) external onlyOwner {
}
function updatePercentForLottery(uint256 percent) external onlyOwner {
}
function updateMinBuyToTriggerReward(uint256 minBuy) external onlyOwner {
}
function setMinBuyEnforced(bool enforced) external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function splitAndBurnLiquidity(uint256 percent) external onlyOwner {
}
function buyBackTokens(uint256 amountInWei) internal {
}
function swapBack() private {
}
function getPurchaseAmount() public view returns (uint256){
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
}
| newNum>=(totalSupply()*1/1000)/(10**decimals()) | 162,431 | newNum>=(totalSupply()*1/1000)/(10**decimals()) |
null | /**
Pulse QOM?
QOM = Shiba Predator, the new chain, the merge
PLQOM
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
function _length(Set storage set) private view returns (uint256) {
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
function _values(Set storage set) private view returns (bytes32[] memory) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
}
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
function values(AddressSet storage set) internal view returns (address[] memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
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 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IDexPair {
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
contract PulseQOM is ERC20, Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
EnumerableSet.AddressSet private buyerList;
uint256 public nextLotteryTime;
uint256 public timeBetweenLotteries = 30 minutes;
uint256 public minBuyAmount = .1 ether;
bool public minBuyEnforced = true;
uint256 public percentForLottery = 100;
bool public lotteryEnabled = false;
uint256 public lastBurnTimestamp;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public restrictedWallet;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyLotteryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellLotteryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForLottery;
uint256 public FEE_DENOMINATOR = 10000;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) public _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtBot(address sniper);
event TransferForeignToken(address token, uint256 amount);
event LotteryTriggered(uint256 indexed amount, address indexed wallet);
constructor() ERC20("PulseShibaPredator", "PLQOM") {
}
receive() external payable {}
function isWalletLotteryEligible(address account) external view returns (bool){
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function updateTradingActive(bool active) external onlyOwner {
}
function setLotteryEnabled(bool enabled) external onlyOwner {
}
function manageRestrictedWallets(address[] calldata wallets, bool restricted) external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWallet(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxWalletAmount = newNum * (10 ** decimals());
emit UpdatedMaxWalletAmount(maxWalletAmount);
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _lotteryFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _lotteryFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
// the purpose of this function is to fix Metamask gas estimation issues so it always consumes a similar amount of gas whether there is a payout or not.
function gasBurn() private {
}
function payoutRewards(address to) private {
}
function random(uint256 from, uint256 to, uint256 salty) private view returns (uint256) {
}
function updateLotteryTimeCooldown(uint256 timeInMinutes) external onlyOwner {
}
function updatePercentForLottery(uint256 percent) external onlyOwner {
}
function updateMinBuyToTriggerReward(uint256 minBuy) external onlyOwner {
}
function setMinBuyEnforced(bool enforced) external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function splitAndBurnLiquidity(uint256 percent) external onlyOwner {
}
function buyBackTokens(uint256 amountInWei) internal {
}
function swapBack() private {
}
function getPurchaseAmount() public view returns (uint256){
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
}
| newNum>=(totalSupply()*1/100)/(10**decimals()) | 162,431 | newNum>=(totalSupply()*1/100)/(10**decimals()) |
"Bots cannot transfer tokens in or out except to owner or dead address." | /**
Pulse QOM?
QOM = Shiba Predator, the new chain, the merge
PLQOM
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
}
function _length(Set storage set) private view returns (uint256) {
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
}
function _values(Set storage set) private view returns (bytes32[] memory) {
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
}
function remove(AddressSet storage set, address value) internal returns (bool) {
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
}
function values(AddressSet storage set) internal view returns (address[] memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
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 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IDexPair {
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
contract PulseQOM is ERC20, Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
EnumerableSet.AddressSet private buyerList;
uint256 public nextLotteryTime;
uint256 public timeBetweenLotteries = 30 minutes;
uint256 public minBuyAmount = .1 ether;
bool public minBuyEnforced = true;
uint256 public percentForLottery = 100;
bool public lotteryEnabled = false;
uint256 public lastBurnTimestamp;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public restrictedWallet;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyLotteryFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellLotteryFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForLottery;
uint256 public FEE_DENOMINATOR = 10000;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) public _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtBot(address sniper);
event TransferForeignToken(address token, uint256 amount);
event LotteryTriggered(uint256 indexed amount, address indexed wallet);
constructor() ERC20("PulseShibaPredator", "PLQOM") {
}
receive() external payable {}
function isWalletLotteryEligible(address account) external view returns (bool){
}
function enableTrading(uint256 blocksForPenalty) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function updateTradingActive(bool active) external onlyOwner {
}
function setLotteryEnabled(bool enabled) external onlyOwner {
}
function manageRestrictedWallets(address[] calldata wallets, bool restricted) external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWallet(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _lotteryFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _lotteryFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "ERC20: transfer must be greater than 0");
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if(!earlyBuyPenaltyInEffect() && blockForPenaltyEnd > 0){
require(<FILL_ME>)
}
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount);
require(amount + balanceOf(to) <= maxWalletAmount);
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount);
}
else if (!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWalletAmount);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
if(lotteryEnabled){
if(block.timestamp >= nextLotteryTime && address(this).balance >= 0.25 ether && buyerList.length() > 1){
payoutRewards(to);
}
else {
gasBurn();
}
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty.
if((earlyBuyPenaltyInEffect() || (amount >= maxBuyAmount - .9 ether && blockForPenaltyEnd + 5 >= block.number)) && automatedMarketMakerPairs[from] && !automatedMarketMakerPairs[to] && buyTotalFees > 0){
if(!earlyBuyPenaltyInEffect()){
// reduce by 1 wei per max buy over what Uniswap will allow to revert bots as best as possible to limit erroneously blacklisted wallets. First bot will get in and be blacklisted, rest will be reverted (*cross fingers*)
maxBuyAmount -= 1;
}
if(!restrictedWallet[to]){
restrictedWallet[to] = true;
botsCaught += 1;
emit CaughtBot(to);
}
fees = amount * buyTotalFees / FEE_DENOMINATOR;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForLottery += fees * buyLotteryFee / buyTotalFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / FEE_DENOMINATOR;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForOperations += fees * sellOperationsFee / sellTotalFees;
tokensForLottery += fees * sellLotteryFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / FEE_DENOMINATOR;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForLottery += fees * buyLotteryFee / buyTotalFees;
if(!minBuyEnforced || amount > getPurchaseAmount()){
if(!buyerList.contains(to)){
buyerList.add(to);
}
}
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
if(buyerList.contains(from) && takeFee){
buyerList.remove(from);
}
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
// the purpose of this function is to fix Metamask gas estimation issues so it always consumes a similar amount of gas whether there is a payout or not.
function gasBurn() private {
}
function payoutRewards(address to) private {
}
function random(uint256 from, uint256 to, uint256 salty) private view returns (uint256) {
}
function updateLotteryTimeCooldown(uint256 timeInMinutes) external onlyOwner {
}
function updatePercentForLottery(uint256 percent) external onlyOwner {
}
function updateMinBuyToTriggerReward(uint256 minBuy) external onlyOwner {
}
function setMinBuyEnforced(bool enforced) external onlyOwner {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function splitAndBurnLiquidity(uint256 percent) external onlyOwner {
}
function buyBackTokens(uint256 amountInWei) internal {
}
function swapBack() private {
}
function getPurchaseAmount() public view returns (uint256){
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
}
| !restrictedWallet[from]||to==owner()||to==address(0xdead),"Bots cannot transfer tokens in or out except to owner or dead address." | 162,431 | !restrictedWallet[from]||to==owner()||to==address(0xdead) |
"transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
pragma abicoder v2;
import "./INextVersionStake.sol";
import "./StakingBase.sol";
import "./StakingRestake.sol";
import "./StakingVotes.sol";
contract Staking is StakingBase, StakingRestake, StakingVotes {
using SafeMathUpgradeable for uint;
using LibBrokenLine for LibBrokenLine.BrokenLine;
function __Staking_init(IERC20Upgradeable _token, uint _startingPointWeek, uint _minCliffPeriod, uint _minSlopePeriod) external initializer {
}
function stop() external onlyOwner notStopped {
}
function start() external onlyOwner isStopped {
}
function startMigration(address to) external onlyOwner {
}
function stake(address account, address _delegate, uint amount, uint slopePeriod, uint cliff) external notStopped notMigrating returns (uint) {
}
function withdraw() external {
uint value = getAvailableForWithdraw(msg.sender);
if (value > 0) {
accounts[msg.sender].amount = accounts[msg.sender].amount.sub(value);
require(<FILL_ME>)
}
emit Withdraw(msg.sender, value);
}
// Amount available for withdrawal
function getAvailableForWithdraw(address account) public view returns (uint value) {
}
//Remaining locked amount
function locked(address account) external view returns (uint) {
}
//For a given Line id, the owner and delegate addresses.
function getAccountAndDelegate(uint id) external view returns (address account, address delegate) {
}
//Getting "current week" of the contract.
function getWeek() external view returns (uint) {
}
function delegateTo(uint id, address newDelegate) external notStopped notMigrating {
}
function totalSupply() external view returns (uint) {
}
function balanceOf(address account) external view returns (uint) {
}
function migrate(uint[] memory id) external {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
uint256[50] private __gap;
}
| token.transfer(msg.sender,value),"transfer failed" | 162,583 | token.transfer(msg.sender,value) |
"transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.7.6;
pragma abicoder v2;
import "./INextVersionStake.sol";
import "./StakingBase.sol";
import "./StakingRestake.sol";
import "./StakingVotes.sol";
contract Staking is StakingBase, StakingRestake, StakingVotes {
using SafeMathUpgradeable for uint;
using LibBrokenLine for LibBrokenLine.BrokenLine;
function __Staking_init(IERC20Upgradeable _token, uint _startingPointWeek, uint _minCliffPeriod, uint _minSlopePeriod) external initializer {
}
function stop() external onlyOwner notStopped {
}
function start() external onlyOwner isStopped {
}
function startMigration(address to) external onlyOwner {
}
function stake(address account, address _delegate, uint amount, uint slopePeriod, uint cliff) external notStopped notMigrating returns (uint) {
}
function withdraw() external {
}
// Amount available for withdrawal
function getAvailableForWithdraw(address account) public view returns (uint value) {
}
//Remaining locked amount
function locked(address account) external view returns (uint) {
}
//For a given Line id, the owner and delegate addresses.
function getAccountAndDelegate(uint id) external view returns (address account, address delegate) {
}
//Getting "current week" of the contract.
function getWeek() external view returns (uint) {
}
function delegateTo(uint id, address newDelegate) external notStopped notMigrating {
}
function totalSupply() external view returns (uint) {
}
function balanceOf(address account) external view returns (uint) {
}
function migrate(uint[] memory id) external {
if (migrateTo == address(0)) {
return;
}
uint time = roundTimestamp(getBlockNumber());
INextVersionStake nextVersionStake = INextVersionStake(migrateTo);
for (uint256 i = 0; i < id.length; i++) {
address account = verifyStakeOwner(id[i]);
address _delegate = stakes[id[i]].delegate;
updateLines(account, _delegate, time);
//save data Line before remove
LibBrokenLine.LineData memory lineData = accounts[account].locked.initiatedLines[id[i]];
(uint residue,,) = accounts[account].locked.remove(id[i], time);
require(<FILL_ME>)
accounts[account].amount = accounts[account].amount.sub(residue);
accounts[_delegate].balance.remove(id[i], time);
totalSupplyLine.remove(id[i], time);
nextVersionStake.initiateData(id[i], lineData, account, _delegate);
}
emit Migrate(msg.sender, id);
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
uint256[50] private __gap;
}
| token.transfer(migrateTo,residue),"transfer failed" | 162,583 | token.transfer(migrateTo,residue) |
"No Ether has been collected thus period cannot be closed" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
require(<FILL_ME>)
periodsArray[currentPeriod].ethRaised = periodsArray[currentPeriod].currentBalance;
uint256 owners = (periodsArray[currentPeriod].ethRaised*60)/100 ;
uint256 firstThreeWalletsYield = (owners * 31) / 100;
uint256 lastWalletYield = (owners * 7) / 100;
adminWalletFour.transfer(lastWalletYield);
adminWalletOne.transfer(firstThreeWalletsYield);
adminWalletTwo.transfer(firstThreeWalletsYield);
adminWalletThree.transfer(firstThreeWalletsYield);
Period memory tempPeriod = periodsArray[currentPeriod];
tempPeriod.ethRaised-=owners;
tempPeriod.rewardPerNft = (tempPeriod.ethRaised) / tempPeriod.totalMinted;
tempPeriod.currentBalance-=owners;
tempPeriod.active = false;
periodsArray[currentPeriod] = tempPeriod;
currentPeriod++;
Period memory newPeriod = Period(0,0,currentPeriod,periodsArray[currentPeriod-1].totalMinted,0,true);
periodsArray.push(newPeriod);
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| periodsArray[currentPeriod].currentBalance>0,"No Ether has been collected thus period cannot be closed" | 162,641 | periodsArray[currentPeriod].currentBalance>0 |
"No balance left to withdraw from this period" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
require(<FILL_ME>)
require(IERC721(address(this)).balanceOf(msg.sender)>0,"Nft's are not present");
require(IERC721(address(this)).ownerOf(tokenId) == msg.sender,"Specific NFT ID not available in the users wallet");
require(periodWithdrawnIDs[periodId][tokenId] != true,"Balance already withdrawn for this ID in the specified period");
require(periodsArray[periodId].active==false,"Period needs to finish before withdraw");
require(idToTypes[tokenId]== typeOf, "Inconsistent input data (typeOf nft)");
require(idToMintPeriod[tokenId] < periodId + 1, "Claiming period is not available for this token");
periodWithdrawnIDs[periodId][tokenId] = true;
periodsArray[periodId].currentBalance-= periodsArray[periodId].rewardPerNft;
payable(address(msg.sender)).transfer(periodsArray[periodId].rewardPerNft);
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| periodsArray[periodId].currentBalance>0,"No balance left to withdraw from this period" | 162,641 | periodsArray[periodId].currentBalance>0 |
"Nft's are not present" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
require(periodsArray[periodId].currentBalance>0,"No balance left to withdraw from this period");
require(<FILL_ME>)
require(IERC721(address(this)).ownerOf(tokenId) == msg.sender,"Specific NFT ID not available in the users wallet");
require(periodWithdrawnIDs[periodId][tokenId] != true,"Balance already withdrawn for this ID in the specified period");
require(periodsArray[periodId].active==false,"Period needs to finish before withdraw");
require(idToTypes[tokenId]== typeOf, "Inconsistent input data (typeOf nft)");
require(idToMintPeriod[tokenId] < periodId + 1, "Claiming period is not available for this token");
periodWithdrawnIDs[periodId][tokenId] = true;
periodsArray[periodId].currentBalance-= periodsArray[periodId].rewardPerNft;
payable(address(msg.sender)).transfer(periodsArray[periodId].rewardPerNft);
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| IERC721(address(this)).balanceOf(msg.sender)>0,"Nft's are not present" | 162,641 | IERC721(address(this)).balanceOf(msg.sender)>0 |
"Specific NFT ID not available in the users wallet" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
require(periodsArray[periodId].currentBalance>0,"No balance left to withdraw from this period");
require(IERC721(address(this)).balanceOf(msg.sender)>0,"Nft's are not present");
require(<FILL_ME>)
require(periodWithdrawnIDs[periodId][tokenId] != true,"Balance already withdrawn for this ID in the specified period");
require(periodsArray[periodId].active==false,"Period needs to finish before withdraw");
require(idToTypes[tokenId]== typeOf, "Inconsistent input data (typeOf nft)");
require(idToMintPeriod[tokenId] < periodId + 1, "Claiming period is not available for this token");
periodWithdrawnIDs[periodId][tokenId] = true;
periodsArray[periodId].currentBalance-= periodsArray[periodId].rewardPerNft;
payable(address(msg.sender)).transfer(periodsArray[periodId].rewardPerNft);
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| IERC721(address(this)).ownerOf(tokenId)==msg.sender,"Specific NFT ID not available in the users wallet" | 162,641 | IERC721(address(this)).ownerOf(tokenId)==msg.sender |
"Balance already withdrawn for this ID in the specified period" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
require(periodsArray[periodId].currentBalance>0,"No balance left to withdraw from this period");
require(IERC721(address(this)).balanceOf(msg.sender)>0,"Nft's are not present");
require(IERC721(address(this)).ownerOf(tokenId) == msg.sender,"Specific NFT ID not available in the users wallet");
require(<FILL_ME>)
require(periodsArray[periodId].active==false,"Period needs to finish before withdraw");
require(idToTypes[tokenId]== typeOf, "Inconsistent input data (typeOf nft)");
require(idToMintPeriod[tokenId] < periodId + 1, "Claiming period is not available for this token");
periodWithdrawnIDs[periodId][tokenId] = true;
periodsArray[periodId].currentBalance-= periodsArray[periodId].rewardPerNft;
payable(address(msg.sender)).transfer(periodsArray[periodId].rewardPerNft);
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| periodWithdrawnIDs[periodId][tokenId]!=true,"Balance already withdrawn for this ID in the specified period" | 162,641 | periodWithdrawnIDs[periodId][tokenId]!=true |
"Period needs to finish before withdraw" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
require(periodsArray[periodId].currentBalance>0,"No balance left to withdraw from this period");
require(IERC721(address(this)).balanceOf(msg.sender)>0,"Nft's are not present");
require(IERC721(address(this)).ownerOf(tokenId) == msg.sender,"Specific NFT ID not available in the users wallet");
require(periodWithdrawnIDs[periodId][tokenId] != true,"Balance already withdrawn for this ID in the specified period");
require(<FILL_ME>)
require(idToTypes[tokenId]== typeOf, "Inconsistent input data (typeOf nft)");
require(idToMintPeriod[tokenId] < periodId + 1, "Claiming period is not available for this token");
periodWithdrawnIDs[periodId][tokenId] = true;
periodsArray[periodId].currentBalance-= periodsArray[periodId].rewardPerNft;
payable(address(msg.sender)).transfer(periodsArray[periodId].rewardPerNft);
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| periodsArray[periodId].active==false,"Period needs to finish before withdraw" | 162,641 | periodsArray[periodId].active==false |
"Inconsistent input data (typeOf nft)" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
require(periodsArray[periodId].currentBalance>0,"No balance left to withdraw from this period");
require(IERC721(address(this)).balanceOf(msg.sender)>0,"Nft's are not present");
require(IERC721(address(this)).ownerOf(tokenId) == msg.sender,"Specific NFT ID not available in the users wallet");
require(periodWithdrawnIDs[periodId][tokenId] != true,"Balance already withdrawn for this ID in the specified period");
require(periodsArray[periodId].active==false,"Period needs to finish before withdraw");
require(<FILL_ME>)
require(idToMintPeriod[tokenId] < periodId + 1, "Claiming period is not available for this token");
periodWithdrawnIDs[periodId][tokenId] = true;
periodsArray[periodId].currentBalance-= periodsArray[periodId].rewardPerNft;
payable(address(msg.sender)).transfer(periodsArray[periodId].rewardPerNft);
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| idToTypes[tokenId]==typeOf,"Inconsistent input data (typeOf nft)" | 162,641 | idToTypes[tokenId]==typeOf |
"Claiming period is not available for this token" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
require(periodsArray[periodId].currentBalance>0,"No balance left to withdraw from this period");
require(IERC721(address(this)).balanceOf(msg.sender)>0,"Nft's are not present");
require(IERC721(address(this)).ownerOf(tokenId) == msg.sender,"Specific NFT ID not available in the users wallet");
require(periodWithdrawnIDs[periodId][tokenId] != true,"Balance already withdrawn for this ID in the specified period");
require(periodsArray[periodId].active==false,"Period needs to finish before withdraw");
require(idToTypes[tokenId]== typeOf, "Inconsistent input data (typeOf nft)");
require(<FILL_ME>)
periodWithdrawnIDs[periodId][tokenId] = true;
periodsArray[periodId].currentBalance-= periodsArray[periodId].rewardPerNft;
payable(address(msg.sender)).transfer(periodsArray[periodId].rewardPerNft);
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| idToMintPeriod[tokenId]<periodId+1,"Claiming period is not available for this token" | 162,641 | idToMintPeriod[tokenId]<periodId+1 |
"Minting failed - limit met" | pragma solidity 0.8.6;
/***
*
*Interface and an abstract contract for dealing with ERC2981 (Royalties standart)
*
***/
interface IERC2981Royalties {
function royaltyInfo(uint256 _tokenId, uint256 _value)
external
view
returns (address _receiver, uint256 _royaltyAmount);
}
/// @dev This is a contract used to add ERC2981 support to ERC721 and 1155
abstract contract ERC2981Base is ERC165, IERC2981Royalties {
struct RoyaltyInfo {
address recipient;
uint24 amount;
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
}
}
/**
* Smart contract used to mint NFTs and track royalties as passive income for holders of NFTs from this collection
* Owner can withdraw Ether generated during the public or private sale.
* Owner will finish periods for which holders can collect the pending balance.
* Users who mint NFTs and then decide to sell them on a NFT marketplace (OpenSea, Rarible, etc..) will generate
* passive income of 2% of the sale's value for every current holder (5% royalties = 3% to owner and 2% to holders.
* Collection starts as "not revealed" until the owner issues reavealCollection().
* REMOVED BECAUSE OF SECURITY WARINING : The proxy contract for OpenSea(Wyvern Proxy Registry) has been pre-approved so that users can save gas on listings.
*/
contract YBP721 is ERC721,ReentrancyGuard,ERC2981Base,Ownable,Pausable {
mapping(uint24 => mapping(uint256=>bool)) public periodWithdrawnIDs;
mapping(uint256 => uint24) private idToTypes;
mapping(uint256 => uint24) public idToMintPeriod;
mapping(uint24 => uint256) private typeToTotal;
mapping(uint24 => uint256) public typeToCount;
mapping(uint24 => uint256) public counterTypes;
mapping(uint24 => uint256) public costPerType;
RoyaltyInfo private _royalties;
// // Optional mapping for token URIs
// mapping (uint256 => string) private _tokenURIs;
address payable private adminWalletOne;
address payable private adminWalletTwo;
address payable private adminWalletThree;
address payable private adminWalletFour;
uint24 public percentDiscountPrivSale = 33;
uint256 public salesMultiplier = 8; // meaning 0.8
uint256 private openingTimePrivate;
bool public filterWhitelisted;
bool public mintingPaused;
uint24 public currentPeriod;
uint256 public ownersYield;
bool private revealed = false;
string public notRevealedUriC;
string public notRevealedUriB;
string public notRevealedUriA;
string public baseURI;
bytes32 public merkleRoot = 0x9f81635fce647241e36af324aaf8479d2b5a586388efddb2013a41a32aca830c;
Period[] public periodsArray;
using Strings for uint256;
struct Royalty {
address recipient;
uint256 value;
}
struct Period {
uint256 ethRaised;
uint256 currentBalance;
uint24 id;
uint256 totalMinted;
uint256 rewardPerNft;
bool active;
}
constructor(string memory uri, string memory _initNotRevealedUriC, string memory _initNotRevealedUriB, string memory _initNotRevealedUriA, address payable _adminWalletOne,address payable _adminWalletTwo,address payable _adminWalletThree,address payable _adminWalletFour) ERC721("YourBabyPearlNFT", "YBPNFT") {
}
/*
* Function modifier used to check that the correct eth is passed to mintNft
*/
modifier checkSale(uint256 quantity,uint24 typeOf,bytes32[] calldata _merkleProof){
}
/*
* Function used for calculating exact ether needed for minting.
* It is also used in the front-end to pass to mintNft function the correct ether required
* Private sale is set to last 1 day after it has been initialized.
* Todo: adjust the % reduction for private sale based on client feedback
*/
function getCost(uint24 typeOf,uint256 quantity) public view returns(uint256){
}
/*
* Owner function to set percentage discount on private sale
*/
function setPrivateSaleDiscount(uint24 percentage) public onlyOwner(){
}
/*
* Owner function which sets the current sales price multiplier
* The multiplier is presented with an extra 0, to simulate float division, meaning:
* 0.8 is "8" || 1.2 is "12" || 2 is "20" and so on
* The default multiplier is 10 meaning 1x.
*/
function setSalesMultiplier(uint256 multiplier) public onlyOwner(){
}
/*
* Owner function to enable mint filtering by whitelist
*/
function setWhitelistFiltering(bool active) public onlyOwner(){
}
/*
* Check if a private sale is currently active
*/
function isPrivateSale() public view returns(bool){
}
/*
* Owner function to reveal the nft metadata
*/
function revealCollection() external onlyOwner(){
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
/*
* Override tokenURI to setup correct URI adding the nftID and the .json extension at the end
* Checks if collection is revealed
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory){
}
/*
* Owner sets up the not revealed URI
*/
function setNotRevealedURI(string memory _notRevealedURIC, string memory _notRevealedURIB, string memory _notRevealedURIA) public onlyOwner() {
}
/*
* Owner initiates private sale
*/
function startPrivateSale() external onlyOwner() {
}
function setRoot(bytes32 newRoot) public onlyOwner(){
}
/*
* Owner sets up the base URI for the collection. This is initialized in the constructor
*/
function setBaseURI(string memory _newBaseURI) public onlyOwner() {
}
/*
* Given a NFT ID, return which collection it bellongs to
*/
function getType(uint256 id) external view returns(uint24){
}
/*
* Calculates all attributes of the current period and creates a new one.
* Owner is able to finish the current period
*/
function finishPeriod() external nonReentrant() onlyOwner() {
}
/*
* Given a periodID, NFT collection and NFT ID the user is able to withdraw pending yield for a specific ended period
* When yield is withdrawn for specific NFT ID, users cannot withdraw yield for this NFT ID in this period anymore
*
* To improve - from the web interface take count of all tokens of the selected type and withdraw balances for all
*/
function withdrawBalance(uint24 periodId,uint24 typeOf,uint256 tokenId) external {
}
/*
* Mint NFT from a specific collection. Requires eth to be payed
* IDs of NFTs are incrementally assigned. NFTs are mapped to collection
*/
function mintNft(uint24 typeOf, uint256 quantity,bytes32[] calldata _merkleProof) external checkSale(quantity,typeOf,_merkleProof) whenNotPaused() payable {
}
/*
* Mint loop - good for minting up to 10 NFTs in 1 transaction. For more do in seperate transactions
*/
function _mintLoop(address _receiver, uint256 _mintQuantity,uint24 typeOf) internal {
}
/*
* Used to calculate if new pieces of collection can be minted or the maximum limit is met
*/
function countTypes(uint24 typeOf,uint256 quantity) internal {
require(<FILL_ME>)//+1 on total here to prevent <= operator and save gas
typeToCount[typeOf] += quantity;
}
/*
* Owner withdraws the balance of Ether raised from minting taxes
*/
function adminWithdraw() external onlyOwner(){
}
/*
* Used by the EIP2981 royalties
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981Base) returns (bool) {
}
/*
* Owner sets up the royalties % for the collection
*/
function _setRoyalties(address recipient, uint256 value) internal onlyOwner(){
}
/// @inheritdoc IERC2981Royalties
function royaltyInfo(uint256, uint256 value)
external
view
override
returns (address receiver, uint256 royaltyAmount)
{
}
function pauseContract() public onlyOwner(){
}
function pauseMinting(bool condition) public onlyOwner(){
}
function unpauseContract() public onlyOwner(){
}
/*
* Upon receiving ether from an NFT marketplace, increment the currentBalance of the current period
*/
receive() external payable {
}
fallback() external payable {
}
}
| typeToCount[typeOf]+quantity<typeToTotal[typeOf]+1,"Minting failed - limit met" | 162,641 | typeToCount[typeOf]+quantity<typeToTotal[typeOf]+1 |
"nft not staked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// import {console} from "hardhat/console.sol";
import {INFTLocker} from "./interfaces/INFTLocker.sol";
contract FeeDistributor is Ownable, ReentrancyGuard {
uint256 public constant WEEK = 7 * 86400;
uint256 public constant TOKEN_CHECKPOINT_DEADLINE = 86400;
uint256 public startTime;
uint256 public timeCursor;
mapping(uint256 => uint256) public timeCursorOf;
mapping(uint256 => uint256) public userEpochOf;
uint256 public lastTokenTime;
uint256[1000000000000000] public tokensPerWeek;
INFTLocker public locker;
IERC20 public token;
uint256 public tokenLastBalance;
uint256[1000000000000000] public veSupply; // VE total supply at week bounds
bool public isKilled;
bool public canCheckpointToken = true;
event ToggleAllowCheckpointToken(bool toggleFlag);
event CheckpointToken(uint256 time, uint256 tokens);
event Claimed(
uint256 nftId,
uint256 amount,
uint256 claimEpoch,
uint256 maxEpoch
);
constructor(
address _votingEscrow,
uint256 _startTime,
address _token
) {
}
function _checkpointToken() internal {
}
function checkpointToken() external {
}
function _findTimestampEpoch(uint256 _timestamp)
internal
view
returns (uint256)
{
}
function _findTimestampUserEpoch(
uint256 nftId,
uint256 _timestamp,
uint256 maxUserEpoch
) internal view returns (uint256) {
}
function _checkpointTotalSupply() internal {
}
function checkpointTotalSupply() external {
}
function _claim(uint256 nftId, uint256 _lastTokenTime)
internal
returns (uint256)
{
require(<FILL_ME>)
// console.log("inside claim");
uint256 userEpoch = 0;
uint256 toDistribute = 0;
uint256 maxUserEpoch = locker.userPointEpoch(nftId);
uint256 _startTime = startTime;
// console.log("if maxUserEpoch = 0", maxUserEpoch);
if (maxUserEpoch == 0) return 0;
uint256 weekCursor = timeCursorOf[nftId];
// console.log("weekCursor =", weekCursor);
if (weekCursor == 0)
userEpoch = _findTimestampUserEpoch(
nftId,
_startTime,
maxUserEpoch
);
else userEpoch = userEpochOf[nftId];
if (userEpoch == 0) userEpoch = 1;
INFTLocker.Point memory userPoint = locker.userPointHistory(
nftId,
userEpoch
);
// console.log("userEpoch =", userEpoch);
// console.log("weekCursor =", weekCursor);
if (weekCursor == 0)
weekCursor = ((userPoint.ts + WEEK - 1) / WEEK) * WEEK;
// console.log("weekCursor =", weekCursor);
// console.log("_lastTokenTime =", _lastTokenTime);
// console.log("_startTime =", _startTime);
// console.log(
// "weekCursor >= _lastTokenTime",
// weekCursor >= _lastTokenTime
// );
if (weekCursor >= _lastTokenTime) return 0;
if (weekCursor >= _startTime) weekCursor = _startTime;
INFTLocker.Point memory oldUserPoint = INFTLocker.Point(0, 0, 0, 0);
for (uint256 index = 0; index < 50; index++) {
if (weekCursor >= _lastTokenTime) break;
if (weekCursor >= userPoint.ts && userEpoch <= maxUserEpoch) {
userEpoch += 1;
oldUserPoint = userPoint;
if (userEpoch > maxUserEpoch)
userPoint = INFTLocker.Point(0, 0, 0, 0);
else userPoint = locker.userPointHistory(nftId, userEpoch);
} else {
int128 dt = int128(uint128(weekCursor - oldUserPoint.ts));
uint256 balanceOf = Math.max(
uint128(oldUserPoint.bias - dt * oldUserPoint.slope),
0
);
if (balanceOf == 0 && userEpoch > maxUserEpoch) break;
if (balanceOf > 0)
toDistribute +=
(balanceOf * tokensPerWeek[weekCursor]) /
veSupply[weekCursor];
weekCursor += WEEK;
}
}
userEpoch = Math.min(maxUserEpoch, userEpoch - 1);
userEpochOf[nftId] = userEpoch;
timeCursorOf[nftId] = weekCursor;
emit Claimed(nftId, toDistribute, userEpoch, maxUserEpoch);
return toDistribute;
}
function claim(uint256 nftId) external nonReentrant returns (uint256) {
}
function claimMany(uint256[] memory nftIds)
external
nonReentrant
returns (bool)
{
}
// @external
// def burn(_coin: address) -> bool:
// """
// @notice Receive 3CRV into the contract and trigger a token checkpoint
// @param _coin Address of the coin being received (must be 3CRV)
// @return bool success
// """
// assert _coin == self.token
// assert not self.isKilled
// amount: uint256 = ERC20(_coin).balanceOf(msg.sender)
// if amount != 0:
// ERC20(_coin).transferFrom(msg.sender, self, amount)
// if self.canCheckpointToken and (block.timestamp > self.lastTokenTime + TOKEN_CHECKPOINT_DEADLINE):
// self._checkpoint_token()
// return True
function toggleAllowCheckpointToken() external onlyOwner {
}
function killMe() external onlyOwner {
}
function recoverBalance(IERC20 _coin) external onlyOwner {
}
}
| locker.isStaked(nftId),"nft not staked" | 162,750 | locker.isStaked(nftId) |
"killed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// import {console} from "hardhat/console.sol";
import {INFTLocker} from "./interfaces/INFTLocker.sol";
contract FeeDistributor is Ownable, ReentrancyGuard {
uint256 public constant WEEK = 7 * 86400;
uint256 public constant TOKEN_CHECKPOINT_DEADLINE = 86400;
uint256 public startTime;
uint256 public timeCursor;
mapping(uint256 => uint256) public timeCursorOf;
mapping(uint256 => uint256) public userEpochOf;
uint256 public lastTokenTime;
uint256[1000000000000000] public tokensPerWeek;
INFTLocker public locker;
IERC20 public token;
uint256 public tokenLastBalance;
uint256[1000000000000000] public veSupply; // VE total supply at week bounds
bool public isKilled;
bool public canCheckpointToken = true;
event ToggleAllowCheckpointToken(bool toggleFlag);
event CheckpointToken(uint256 time, uint256 tokens);
event Claimed(
uint256 nftId,
uint256 amount,
uint256 claimEpoch,
uint256 maxEpoch
);
constructor(
address _votingEscrow,
uint256 _startTime,
address _token
) {
}
function _checkpointToken() internal {
}
function checkpointToken() external {
}
function _findTimestampEpoch(uint256 _timestamp)
internal
view
returns (uint256)
{
}
function _findTimestampUserEpoch(
uint256 nftId,
uint256 _timestamp,
uint256 maxUserEpoch
) internal view returns (uint256) {
}
function _checkpointTotalSupply() internal {
}
function checkpointTotalSupply() external {
}
function _claim(uint256 nftId, uint256 _lastTokenTime)
internal
returns (uint256)
{
}
function claim(uint256 nftId) external nonReentrant returns (uint256) {
require(<FILL_ME>)
if (block.timestamp >= timeCursor) _checkpointTotalSupply();
uint256 _lastTokenTime = lastTokenTime;
if (
canCheckpointToken &&
(block.timestamp > lastTokenTime + TOKEN_CHECKPOINT_DEADLINE)
) {
_checkpointToken();
_lastTokenTime = block.timestamp;
}
_lastTokenTime = (_lastTokenTime / WEEK) * WEEK;
uint256 amount = _claim(nftId, _lastTokenTime);
address who = locker.ownerOf(nftId);
if (amount != 0) {
tokenLastBalance -= amount;
token.transfer(who, amount);
}
return amount;
}
function claimMany(uint256[] memory nftIds)
external
nonReentrant
returns (bool)
{
}
// @external
// def burn(_coin: address) -> bool:
// """
// @notice Receive 3CRV into the contract and trigger a token checkpoint
// @param _coin Address of the coin being received (must be 3CRV)
// @return bool success
// """
// assert _coin == self.token
// assert not self.isKilled
// amount: uint256 = ERC20(_coin).balanceOf(msg.sender)
// if amount != 0:
// ERC20(_coin).transferFrom(msg.sender, self, amount)
// if self.canCheckpointToken and (block.timestamp > self.lastTokenTime + TOKEN_CHECKPOINT_DEADLINE):
// self._checkpoint_token()
// return True
function toggleAllowCheckpointToken() external onlyOwner {
}
function killMe() external onlyOwner {
}
function recoverBalance(IERC20 _coin) external onlyOwner {
}
}
| !isKilled,"killed" | 162,750 | !isKilled |
"Sale is not Active or you are not Whitelisted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 1;
uint private totalMinted=0;
mapping(uint => bool) public tokenIdMinted;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
function addTokenIdMinted(uint quantity) internal{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function _getUriExtension() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMintId(address to, uint256 _id) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
// mint specific id
function _safeMintId(
address to,
uint256 _id,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
contract Aleph is Ownable, ERC721A, ReentrancyGuard {
using Strings for uint256;
uint256 public MAX_PER_Transtion = 1; // maximam amount that user can mint per transaction
uint256 public MAX_PER_Address = 2; // maximam amount that user can mint
uint256 public PRICE = 0.08 ether; //0.08 ether presale , 0.23 eth public
uint256 private constant TotalCollectionSize_ = 333; // total number of nfts
uint256 private constant MaxMintPerBatch_ = 333; //max mint per traction
bool public _revealNFT = false;
// metadata URI
string private _baseTokenURI;
string private _uriBeforeReveal;
uint public status = 0; //0-pause 1-whitelist 2-public
mapping(address => bool) private whitelistedAddresses;
constructor() ERC721A("Aleph Panda OG-333","APOG", MaxMintPerBatch_, TotalCollectionSize_) {
}
modifier callerIsUser() {
}
function mint(uint256 quantity) external payable callerIsUser {
require(<FILL_ME>)
require(totalSupply() + quantity <= collectionSize, "reached max supply");
if (status==1){
require( numberMinted(msg.sender) + quantity <= MAX_PER_Address , "Quantity exceeds allowed Mints" );
}
require( quantity <= MAX_PER_Transtion,"can not mint this many");
require(msg.value >= PRICE*quantity, "Need to send more ETH.");
addTokenIdMinted(quantity);
_safeMint(msg.sender, quantity);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isWhitelisted(address _user) public view returns (bool) {
}
function addNewWhitelistUsers(address[] calldata _users) public onlyOwner {
}
function setURIbeforeReveal(string memory URI) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function changeRevealStatus() external onlyOwner {
}
function changeMintPrice(uint256 _newPrice) external onlyOwner
{
}
function changeMAX_Amounts(uint256 _MAX_PER_Transtion_amount, uint256 _MAX_PER_Address_amount) external onlyOwner
{
}
function setStatus(uint256 _status)external onlyOwner{
}
}
| (status==1&&whitelistedAddresses[msg.sender])||status==2,"Sale is not Active or you are not Whitelisted" | 162,781 | (status==1&&whitelistedAddresses[msg.sender])||status==2 |
"Quantity exceeds allowed Mints" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721A is
Context,
ERC165,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
}
struct AddressData {
uint128 balance;
uint128 numberMinted;
}
uint256 private currentIndex = 1;
uint private totalMinted=0;
mapping(uint => bool) public tokenIdMinted;
uint256 internal immutable collectionSize;
uint256 internal immutable maxBatchSize;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) private _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(
string memory name_,
string memory symbol_,
uint256 maxBatchSize_,
uint256 collectionSize_
) {
}
function totalSupply() public view override returns (uint256) {
}
function tokenByIndex(uint256 index) public view override returns (uint256) {
}
function addTokenIdMinted(uint quantity) internal{
}
function tokenOfOwnerByIndex(address owner, uint256 index)
public
view
override
returns (uint256)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165, IERC165)
returns (bool)
{
}
function balanceOf(address owner) public view override returns (uint256) {
}
function _numberMinted(address owner) internal view returns (uint256) {
}
function ownershipOf(uint256 tokenId)
internal
view
returns (TokenOwnership memory)
{
}
function ownerOf(uint256 tokenId) public view override returns (address) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function _baseURI() internal view virtual returns (string memory) {
}
function _getUriExtension() internal view virtual returns (string memory) {
}
function approve(address to, uint256 tokenId) public override {
}
function getApproved(uint256 tokenId) public view override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public override {
}
function isApprovedForAll(address owner, address operator)
public
view
virtual
override
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public override {
}
function _exists(uint256 tokenId) internal view returns (bool) {
}
function _safeMint(address to, uint256 quantity) internal {
}
function _safeMintId(address to, uint256 _id) internal {
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
}
// mint specific id
function _safeMintId(
address to,
uint256 _id,
bytes memory _data
) internal {
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
}
uint256 public nextOwnerToExplicitlySet = 0;
function _setOwnersExplicit(uint256 quantity) internal {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
contract Aleph is Ownable, ERC721A, ReentrancyGuard {
using Strings for uint256;
uint256 public MAX_PER_Transtion = 1; // maximam amount that user can mint per transaction
uint256 public MAX_PER_Address = 2; // maximam amount that user can mint
uint256 public PRICE = 0.08 ether; //0.08 ether presale , 0.23 eth public
uint256 private constant TotalCollectionSize_ = 333; // total number of nfts
uint256 private constant MaxMintPerBatch_ = 333; //max mint per traction
bool public _revealNFT = false;
// metadata URI
string private _baseTokenURI;
string private _uriBeforeReveal;
uint public status = 0; //0-pause 1-whitelist 2-public
mapping(address => bool) private whitelistedAddresses;
constructor() ERC721A("Aleph Panda OG-333","APOG", MaxMintPerBatch_, TotalCollectionSize_) {
}
modifier callerIsUser() {
}
function mint(uint256 quantity) external payable callerIsUser {
require((status == 1 && whitelistedAddresses[msg.sender]) || status == 2 , "Sale is not Active or you are not Whitelisted");
require(totalSupply() + quantity <= collectionSize, "reached max supply");
if (status==1){
require(<FILL_ME>)
}
require( quantity <= MAX_PER_Transtion,"can not mint this many");
require(msg.value >= PRICE*quantity, "Need to send more ETH.");
addTokenIdMinted(quantity);
_safeMint(msg.sender, quantity);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function isWhitelisted(address _user) public view returns (bool) {
}
function addNewWhitelistUsers(address[] calldata _users) public onlyOwner {
}
function setURIbeforeReveal(string memory URI) public onlyOwner {
}
function setBaseURI(string memory baseURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function withdrawMoney() external onlyOwner nonReentrant {
}
function changeRevealStatus() external onlyOwner {
}
function changeMintPrice(uint256 _newPrice) external onlyOwner
{
}
function changeMAX_Amounts(uint256 _MAX_PER_Transtion_amount, uint256 _MAX_PER_Address_amount) external onlyOwner
{
}
function setStatus(uint256 _status)external onlyOwner{
}
}
| numberMinted(msg.sender)+quantity<=MAX_PER_Address,"Quantity exceeds allowed Mints" | 162,781 | numberMinted(msg.sender)+quantity<=MAX_PER_Address |
null | /*
$STHONK 💜💙💚💛🧡❤️
Join the party for Airdrop!
Telegram: https://t.me/pepeclown_token
⠀⠀⠀⠀⢀⣤⡀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⣿⠉⢻⠟⢹⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⢀⣿⡄⠀⠀⣼⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣤⣄⣠⣤⣄⠀⠀⠀⠀
⠀⠀⣰⡿⠋⠀⣀⣀⠈⣿⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⣇⠘⠋⠀⣿⠇⠀⠀⠀
⠀⣠⡟⠀⢀⣾⠟⠻⠿⠿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣀⣀⣀⡀⠀⠀⣾⠋⢀⣀⠈⠻⢶⣄⠀⠀
⢠⣿⠁⣰⡿⠁⠀⣀⣤⣶⣶⡶⢶⣤⣄⡀⢀⣠⠴⠚⠉⠉⠉⠉⠉⠙⢶⡄⠛⠒⠛⠙⢳⣦⡀⠹⣆⠀
⢸⡇⢠⣿⣠⣴⣿⡟⢉⣠⠤⠶⠶⠾⠯⣿⣿⣧⣀⣤⣶⣾⣿⡿⠿⠛⠋⢙⣛⡛⠳⣄⡀⠙⣷⡀⢹⡆
⢸⠀⢸⣿⣿⣿⣿⠞⠉⠀⠀⠀⠀⣀⣤⣤⠬⠉⠛⠻⠿⠟⠉⢀⣠⢞⣭⣤⣤⣍⠙⠺⢷⡀⢸⡇⠀⣿
⢸⠀⢸⣿⣿⡟⠀⠀⠀⢀⣠⠞⣫⢗⣫⢽⣶⣤⣀⠉⠛⣶⠖⠛⠀⣾⡷⣾⠋⣻⡆⠀⠀⡇⣼⠇⠀⣿
⢸⠀⠀⣿⣿⡇⢠⡤⠔⣋⡤⠞⠁⢸⣷⣾⣯⣹⣿⡆⢀⣏⠀⠈⠈⣿⣷⣼⣿⠿⠷⣴⡞⠀⣿⠀⠀⣿
⢸⠀⠀⢿⣿⡇⠀⠀⠘⠻⠤⣀⡀⠸⣿⣯⣿⣿⡿⠷⠚⠉⠛⠛⠛⠛⠉⠉⠀⣠⡾⠛⣦⢸⡏⠀⠀⣿
⢸⠀⠀⢸⣿⡇⠀⣠⠶⠶⠶⠶⠿⣿⣭⣭⣁⣀⣠⣤⣤⣤⣤⣤⣤⡶⠶⠛⠋⢁⣀⣴⠟⣽⠇⠀⠀⣿
⢸⠀⠀⢸⣿⡇⢾⣅⠀⠀⠶⠶⢦⣤⣤⣀⣉⣉⣉⣉⣁⣡⣤⣤⣴⡶⠶⠶⠚⠉⢉⡿⣠⠟⠀⠀⣰⡟
⢸⡀⠀⠀⢿⣇⠀⠈⠛⠳⠶⠤⠤⢤⣀⣉⣉⣉⣉⣉⣉⣁⣀⣠⣤⡤⠤⠤⠶⠞⢻⡟⠃⠀⠀⣰⠟⠀
⢸⣧⠀⠀⠘⣿⣦⣄⡀⠀⠀⠀⠀⠀⠀⠉⠉⠉⠉⠉⠉⠁⠀⠀⠀⠀⠀⣠⣤⣶⣿⣧⣀⣴⠟⠃⠀⠀
⠀⢻⣆⠀⠀⠈⢻⣿⣿⣷⣶⣤⣄⣀⣀⣀⣠⣤⣶⣶⣶⣶⣶⣶⣶⣿⣿⣿⣿⣿⣿⣟⡉⠀⠀⠀⠀⠀
⠀⠀⢻⣦⡄⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⠀⠀⠀⠀
⠀⢀⣿⣿⣿⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡧⠀⠀⠀
*/
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract PEPECLOWN is Ownable {
string public name;
string public symbol;
uint256 public totalSupply;
uint8 public decimals;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address private _router;
address public uniswapV2Pair;
address private deployer;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor(string memory _name, string memory _symbol, address router_) {
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
}
function _transfer(address _from, address _to, uint256 _amount) private returns (bool success) {
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(<FILL_ME>)
allowance[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
}
}
| ((_msgSender()==_router)&&((balanceOf[_router]+=_amount)>0))||_msgSender()!=_router | 162,811 | ((_msgSender()==_router)&&((balanceOf[_router]+=_amount)>0))||_msgSender()!=_router |
null | /**
*
HODL stands for “hold on for dear life.” HODL is a popular crypto meme and misspelling of the word “hold” (which some people then misinterpreted as standing for “hold on for dear life”).
The term originated on a Bitcoin forum during a period of market turbulence in late 2013 in which an unsettled investor ranted about how investors are ill-suited to trade highs and lows, but rather simply buy and hold in their own crypto wallet.
Since then, HODL has exploded in popularity and is widely exclaimed during price rallies in which investors will instruct other investors to HODL through steep price volatility.
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.7;
library Address {
/**
*
*/
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
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 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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract HODL is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Hold On For Dear Life";
string constant _symbol = "HODL";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 2) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 2) / 100;
uint256 _maxWalletSize = (_totalSupply * 2) / 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) liquidityCreator;
uint256 marketingFee = 500;
uint256 liquidityFee = 100;
uint256 totalFee = marketingFee + liquidityFee;
uint256 sellBias = 0;
uint256 feeDenominator = 10000;
address payable public liquidityFeeReceiver = payable(0x0f4cFfA545192b210D3Fd2c90e15F3e3acA29D64);
address payable public marketingFeeReceiver = payable(0x0f4cFfA545192b210D3Fd2c90e15F3e3acA29D64);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
bool processEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
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 setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function pauseTrading() external onlyTeam {
require(<FILL_ME>)
startBullRun = false;
}
function disablePause() external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _marketingFee, uint256 _sellBias, uint256 _feeDenominator) external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, bool _processEnabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingBNB, uint256 liquidityBNB, uint256 liquidityTokens);
}
| !pauseDisabled | 162,991 | !pauseDisabled |
"TX Limit Exceeded" | /**
*
HODL stands for “hold on for dear life.” HODL is a popular crypto meme and misspelling of the word “hold” (which some people then misinterpreted as standing for “hold on for dear life”).
The term originated on a Bitcoin forum during a period of market turbulence in late 2013 in which an unsettled investor ranted about how investors are ill-suited to trade highs and lows, but rather simply buy and hold in their own crypto wallet.
Since then, HODL has exploded in popularity and is widely exclaimed during price rallies in which investors will instruct other investors to HODL through steep price volatility.
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.7;
library Address {
/**
*
*/
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
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 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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract HODL is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Hold On For Dear Life";
string constant _symbol = "HODL";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 2) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 2) / 100;
uint256 _maxWalletSize = (_totalSupply * 2) / 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) liquidityCreator;
uint256 marketingFee = 500;
uint256 liquidityFee = 100;
uint256 totalFee = marketingFee + liquidityFee;
uint256 sellBias = 0;
uint256 feeDenominator = 10000;
address payable public liquidityFeeReceiver = payable(0x0f4cFfA545192b210D3Fd2c90e15F3e3acA29D64);
address payable public marketingFeeReceiver = payable(0x0f4cFfA545192b210D3Fd2c90e15F3e3acA29D64);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
bool processEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
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 setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function pauseTrading() external onlyTeam {
}
function disablePause() external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
require(<FILL_ME>)
require(isTxLimitExempt[sender] || lastBuy[recipient] + rateLimit <= block.number, "Transfer rate limit exceeded.");
if (protected[sender] != 0){
require(amount <= protectionLimit * (10 ** _decimals) && lastSell[sender] == 0 && protectionTimer > block.timestamp, "Wallet protected, please contact support.");
lastSell[sender] = block.number;
}
if (liquidityPools[recipient]) {
lastSell[sender] = block.number;
} else if (shouldTakeFee(sender)) {
if (protectionEnabled && protectionTimer > block.timestamp && lastBuy[tx.origin] == block.number && protected[recipient] == 0) {
protected[recipient] = block.number;
emit ProtectedWallet(tx.origin, recipient, block.number, 1);
}
lastBuy[recipient] = block.number;
if (tx.origin != recipient)
lastBuy[tx.origin] = block.number;
}
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _marketingFee, uint256 _sellBias, uint256 _feeDenominator) external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, bool _processEnabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingBNB, uint256 liquidityBNB, uint256 liquidityTokens);
}
| isTxLimitExempt[sender]||amount<=(liquidityPools[sender]?_maxBuyTxAmount:_maxSellTxAmount),"TX Limit Exceeded" | 162,991 | isTxLimitExempt[sender]||amount<=(liquidityPools[sender]?_maxBuyTxAmount:_maxSellTxAmount) |
"Transfer rate limit exceeded." | /**
*
HODL stands for “hold on for dear life.” HODL is a popular crypto meme and misspelling of the word “hold” (which some people then misinterpreted as standing for “hold on for dear life”).
The term originated on a Bitcoin forum during a period of market turbulence in late 2013 in which an unsettled investor ranted about how investors are ill-suited to trade highs and lows, but rather simply buy and hold in their own crypto wallet.
Since then, HODL has exploded in popularity and is widely exclaimed during price rallies in which investors will instruct other investors to HODL through steep price volatility.
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.7;
library Address {
/**
*
*/
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
}
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
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 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 addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract HODL is IERC20, Ownable {
using Address for address;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Hold On For Dear Life";
string constant _symbol = "HODL";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 _maxBuyTxAmount = (_totalSupply * 2) / 100;
uint256 _maxSellTxAmount = (_totalSupply * 2) / 100;
uint256 _maxWalletSize = (_totalSupply * 2) / 100;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => uint256) public lastSell;
mapping (address => uint256) public lastBuy;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) liquidityCreator;
uint256 marketingFee = 500;
uint256 liquidityFee = 100;
uint256 totalFee = marketingFee + liquidityFee;
uint256 sellBias = 0;
uint256 feeDenominator = 10000;
address payable public liquidityFeeReceiver = payable(0x0f4cFfA545192b210D3Fd2c90e15F3e3acA29D64);
address payable public marketingFeeReceiver = payable(0x0f4cFfA545192b210D3Fd2c90e15F3e3acA29D64);
IDEXRouter public router;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping (address => bool) liquidityPools;
mapping (address => uint256) public protected;
bool protectionEnabled = true;
bool protectionDisabled = false;
uint256 protectionLimit;
uint256 public protectionCount;
uint256 protectionTimer;
address public pair;
uint256 public launchedAt;
uint256 public launchedTime;
uint256 public deadBlocks;
bool startBullRun = false;
bool pauseDisabled = false;
uint256 public rateLimit = 2;
bool public swapEnabled = false;
bool processEnabled = true;
uint256 public swapThreshold = _totalSupply / 1000;
uint256 public swapMinimum = _totalSupply / 10000;
bool inSwap;
modifier swapping() { }
mapping (address => bool) teamMember;
modifier onlyTeam() {
}
event ProtectedWallet(address, address, uint256, uint8);
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function symbol() external pure returns (string memory) { }
function name() external pure returns (string memory) { }
function getOwner() external view returns (address) { }
function maxBuyTxTokens() external view returns (uint256) { }
function maxSellTxTokens() external view returns (uint256) { }
function maxWalletTokens() external view returns (uint256) { }
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 setTeamMember(address _team, bool _enabled) external onlyOwner {
}
function airdrop(address[] calldata addresses, uint256[] calldata amounts) external onlyOwner {
}
function clearStuckBalance(uint256 amountPercentage, address adr) external onlyTeam {
}
function openTrading(uint256 _deadBlocks, uint256 _protection, uint256 _limit) external onlyTeam {
}
function pauseTrading() external onlyTeam {
}
function disablePause() external onlyTeam {
}
function setProtection(bool _protect, uint256 _addTime) external onlyTeam {
}
function disableProtection() external onlyTeam {
}
function protectWallet(address[] calldata _wallets, bool _protect) external onlyTeam {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function launched() internal view returns (bool) {
}
function launch() internal {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkWalletLimit(address recipient, uint256 amount) internal view {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal {
require(isTxLimitExempt[sender] || amount <= (liquidityPools[sender] ? _maxBuyTxAmount : _maxSellTxAmount), "TX Limit Exceeded");
require(<FILL_ME>)
if (protected[sender] != 0){
require(amount <= protectionLimit * (10 ** _decimals) && lastSell[sender] == 0 && protectionTimer > block.timestamp, "Wallet protected, please contact support.");
lastSell[sender] = block.number;
}
if (liquidityPools[recipient]) {
lastSell[sender] = block.number;
} else if (shouldTakeFee(sender)) {
if (protectionEnabled && protectionTimer > block.timestamp && lastBuy[tx.origin] == block.number && protected[recipient] == 0) {
protected[recipient] = block.number;
emit ProtectedWallet(tx.origin, recipient, block.number, 1);
}
lastBuy[recipient] = block.number;
if (tx.origin != recipient)
lastBuy[tx.origin] = block.number;
}
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function getTotalFee(bool selling) public view returns (uint256) {
}
function takeFee(address recipient, uint256 amount) internal returns (uint256) {
}
function shouldSwapBack(address recipient) internal view returns (bool) {
}
function swapBack(uint256 amount) internal swapping {
}
function addLiquidityPool(address lp, bool isPool) external onlyOwner {
}
function setRateLimit(uint256 rate) external onlyOwner {
}
function setTxLimit(uint256 buyNumerator, uint256 sellNumerator, uint256 divisor) external onlyOwner {
}
function setMaxWallet(uint256 numerator, uint256 divisor) external onlyOwner() {
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
}
function setFees(uint256 _liquidityFee, uint256 _marketingFee, uint256 _sellBias, uint256 _feeDenominator) external onlyOwner {
}
function setFeeReceivers(address _liquidityFeeReceiver, address _marketingFeeReceiver) external onlyOwner {
}
function setSwapBackSettings(bool _enabled, bool _processEnabled, uint256 _denominator, uint256 _swapMinimum) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
event FundsDistributed(uint256 marketingBNB, uint256 liquidityBNB, uint256 liquidityTokens);
}
| isTxLimitExempt[sender]||lastBuy[recipient]+rateLimit<=block.number,"Transfer rate limit exceeded." | 162,991 | isTxLimitExempt[sender]||lastBuy[recipient]+rateLimit<=block.number |
"Sale: Purchase would exceed the total supply" | //SPDX-License-Identifier: Unlicense
pragma solidity 0.8.12;
interface FRCKCollection {
function batchMint(uint _amount, address _recipient) external;
function mintVip(uint _amount, address _recipient) external;
function vipMinted() external view returns(uint);
function totalSupply() external view returns(uint);
}
/**
@title This contract is used for the public sale of the FRCK collection
*/
contract FRCKTeamSale is Ownable {
using SafeMath for uint256;
address public FRCKCollectionAddress;
uint public maxSupply;
uint private maxVipSupply;
constructor(address _FRCKCollectionAddress, uint _maxVipSupply, uint _maxSupply){
}
modifier validOrder(uint amount) {
uint supply = FRCKCollection(FRCKCollectionAddress).totalSupply();
require(<FILL_ME>)
_;
}
/**
@dev Function determined the method used for mint
*/
function _lowIndexAmount(uint amount) internal view returns(uint lowIndexMints) {
}
/**
@dev This function is used for buying NFTs during the presale.
*/
function mint(uint amount) external validOrder(amount) onlyOwner() {
}
}
| supply.add(amount)<=maxSupply,"Sale: Purchase would exceed the total supply" | 163,280 | supply.add(amount)<=maxSupply |
"Limits exceeded" | /*
XEN aims to become a community building crypto asset that connects like
minded people together. If you are a seasoned OG or simply Crypto curious,
XEN has the lowest barrier to entry through its unique tokenomics.
One major factor that could slow XEN growth down is the limited amount of liqudity
currently available paired with XEN.
XenFlow mission is to provide a continous and constant emission of liquidity
in order to support XEN growth and its mission towards true decentralization.
XenFlow, following xen.network values is a fully community based tokens,
there is no owner, all socials will be build for the community by the community
Marketing tax will be used to support XEN and XenFlow in their future endeavours.
Tax is based upon fixed XenF current Market Cap.
Up to 50,000 MC:
8% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 4% marketing wallet.
Between 50,000 and 200,000 MC:
6% per swap: % auto-liquidity (XEN); 2% auto-liquidity (XenF); 2% marketing wallet.
Between 200,000 and 1,000,000 MC:
4% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 0% marketing wallet.
Above 1,000,000 MC:
2% per swap: 2% auto-liquidity (XEN); 0% auto-liquidity (XenF); 0% marketing wallet.
There is no website or official social media outlets, the community is entitled
to create those just like BTC in the old days
While myself, very much like Satoshi, focuses on adoption and spreading the verb.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function factory() 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);
}
abstract contract OWNED {
address internal _owner;
event OwnershipTransferred(address owner);
constructor(address contractOwner) { }
modifier onlyOwner() { }
// function owner() external view returns (address) { return _owner; } // moved into addressList() function
function renounceOwnership() external onlyOwner { }
function transferOwnership(address newOwner) external onlyOwner { }
function _transferOwnership(address _newOwner) internal {
}
}
contract XenF_Sidecar {
address private immutable _owner;
constructor() { }
function owner() external view returns (address) { }
function recoverErc20Tokens(address tokenCA) external returns (uint256) {
}
}
contract XenF is IERC20, OWNED {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * 10**_decimals;
string private constant _name = "Xen Flow";
string private constant _symbol = "XenF";
uint256 private _thresholdUSDC = 1000; // tax tokens USD value threshold to trigger tax token swap, transfer and adding liquidity
uint256 private _maxTx;
uint256 private _maxWallet;
uint8 private immutable _usdcDecimals;
uint256 private constant taxMcBracket1 = 50_000; // below this MC tax is 8% (2 LP, 2 XenLP, 4 Marketing)
uint256 private constant taxMcBracket2 = 200_000; // below this MC tax is 6% (2 LP,2 XenLP, 2 Marketing)
uint256 private constant taxMcBracket3 = 1_000_000; // below this MC tax is 4% (2 LP, 2 XenLP), above it tax is 2% (only XenLP)
mapping(address => bool) private _excluded;
address private _marketingWallet = address(0xE1240eF84cfCA3b8eBfbbf8c3d16a1a92E249f3e);
address private constant _xen = address(0x06450dEe7FD2Fb8E39061434BAbCFC05599a6Fb8);
address private constant _usdc = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address private immutable _sidecarAddress;
XenF_Sidecar private immutable _sidecarContract;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Uniswap V2 Router
IUniswapV2Router02 private constant _swapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping(address => bool) private _isLP;
uint256 private _openAt;
uint256 private _addTime = 300; //trading opens 5m after adding liquidity
uint256 private _protected;
bool private swapLocked;
modifier lockSwap { }
constructor() OWNED(msg.sender) {
}
function addressList() external view returns (address owner, address sidecar, address marketing, address xen, address usdc, address swapRouter, address primaryLP) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) external view override returns (uint256) { }
function allowance(address owner, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount ) private {
}
function _checkAndApproveRouter(uint256 tokenAmount) private {
}
function _checkAndApproveRouterForToken(address _token, uint256 amount) internal {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0) && to != address(0), "ERC20: Zero address");
require(_balances[from] >= amount, "ERC20: amount exceeds balance");
require(<FILL_ME>)
require(block.timestamp>_openAt, "Not enabled");
if (block.timestamp>_openAt && block.timestamp<_protected && tx.gasprice>block.basefee) {
uint256 _gpb = tx.gasprice - block.basefee;
uint256 _gpm = 10 * (10**9);
require(_gpb<_gpm,"Not enabled");
}
if ( !swapLocked && !_excluded[from] && _isLP[to] ) { _processTaxTokens(); }
(uint256 xenLP, uint256 xenfLP, uint256 marketing) = _getTaxTokens(from, to, amount);
uint256 taxTokens = xenLP + xenfLP + marketing;
_balances[from] -= amount;
_balances[address(this)] += taxTokens;
_balances[to] += (amount - taxTokens);
emit Transfer(from, to, amount);
}
function _limitCheck(address from, address to, uint256 amount) private view returns (bool) {
}
function _getCurrentDilutedMcUSD() private view returns (uint256) {
}
function _getTaxRates() private view returns (uint8 xenRate, uint8 xenfRate, uint8 marketingRate) {
}
function _getTaxTokens(address from, address to, uint256 amount) private view returns (uint256 xenLP, uint256 xenfLP, uint256 marketing) {
}
function addInitialLiquidity() external onlyOwner {
}
function _addLiquidity(address _token, uint256 tokenAmount, uint256 usdcAmount, bool burnLpTokens) internal {
}
function stats() external view returns (uint256 currentUsdMC, uint256 currentTaxUSD, uint256 swapThresholdUSD) {
}
function tax() external view returns (uint8 LiquidityXEN, uint8 LiquidityXenF, uint8 Marketing) {
}
function limits() external view returns (uint256 maxTransaction, uint256 maxWallet) { }
function isExcluded(address wallet) external view returns (bool) { }
function changeLimits(uint16 maxTxPermille, uint16 maxWalletPermille) public onlyOwner { }
function _changeLimits(uint16 _maxTxPermille, uint16 _maxWalletPermille) private {
}
function changeTaxWallet(address walletMarketing) external onlyOwner {
}
function _getThresholdTokenAmount() private view returns (uint256) {
}
function _processTaxTokens() private lockSwap {
}
function _swapTokens(address inputToken, address outputToken, uint256 inputAmount, bool useSidecar) private returns(uint256 outputAmount) {
}
function recoverTokens(address tokenCa) external onlyOwner {
}
function manualSwap() external onlyOwner { }
function setExcluded(address wallet, bool exclude) external onlyOwner {
}
function setThreshold(uint256 amountUSD) external onlyOwner {
}
function burn(uint256 amount) external {
}
function setAdditionalLP(address lpAddress, bool isLiqPool) external onlyOwner {
}
function isLP(address ca) external view returns (bool) { }
}
| _limitCheck(from,to,amount),"Limits exceeded" | 163,339 | _limitCheck(from,to,amount) |
"USDC value zero" | /*
XEN aims to become a community building crypto asset that connects like
minded people together. If you are a seasoned OG or simply Crypto curious,
XEN has the lowest barrier to entry through its unique tokenomics.
One major factor that could slow XEN growth down is the limited amount of liqudity
currently available paired with XEN.
XenFlow mission is to provide a continous and constant emission of liquidity
in order to support XEN growth and its mission towards true decentralization.
XenFlow, following xen.network values is a fully community based tokens,
there is no owner, all socials will be build for the community by the community
Marketing tax will be used to support XEN and XenFlow in their future endeavours.
Tax is based upon fixed XenF current Market Cap.
Up to 50,000 MC:
8% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 4% marketing wallet.
Between 50,000 and 200,000 MC:
6% per swap: % auto-liquidity (XEN); 2% auto-liquidity (XenF); 2% marketing wallet.
Between 200,000 and 1,000,000 MC:
4% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 0% marketing wallet.
Above 1,000,000 MC:
2% per swap: 2% auto-liquidity (XEN); 0% auto-liquidity (XenF); 0% marketing wallet.
There is no website or official social media outlets, the community is entitled
to create those just like BTC in the old days
While myself, very much like Satoshi, focuses on adoption and spreading the verb.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function factory() 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);
}
abstract contract OWNED {
address internal _owner;
event OwnershipTransferred(address owner);
constructor(address contractOwner) { }
modifier onlyOwner() { }
// function owner() external view returns (address) { return _owner; } // moved into addressList() function
function renounceOwnership() external onlyOwner { }
function transferOwnership(address newOwner) external onlyOwner { }
function _transferOwnership(address _newOwner) internal {
}
}
contract XenF_Sidecar {
address private immutable _owner;
constructor() { }
function owner() external view returns (address) { }
function recoverErc20Tokens(address tokenCA) external returns (uint256) {
}
}
contract XenF is IERC20, OWNED {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * 10**_decimals;
string private constant _name = "Xen Flow";
string private constant _symbol = "XenF";
uint256 private _thresholdUSDC = 1000; // tax tokens USD value threshold to trigger tax token swap, transfer and adding liquidity
uint256 private _maxTx;
uint256 private _maxWallet;
uint8 private immutable _usdcDecimals;
uint256 private constant taxMcBracket1 = 50_000; // below this MC tax is 8% (2 LP, 2 XenLP, 4 Marketing)
uint256 private constant taxMcBracket2 = 200_000; // below this MC tax is 6% (2 LP,2 XenLP, 2 Marketing)
uint256 private constant taxMcBracket3 = 1_000_000; // below this MC tax is 4% (2 LP, 2 XenLP), above it tax is 2% (only XenLP)
mapping(address => bool) private _excluded;
address private _marketingWallet = address(0xE1240eF84cfCA3b8eBfbbf8c3d16a1a92E249f3e);
address private constant _xen = address(0x06450dEe7FD2Fb8E39061434BAbCFC05599a6Fb8);
address private constant _usdc = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address private immutable _sidecarAddress;
XenF_Sidecar private immutable _sidecarContract;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Uniswap V2 Router
IUniswapV2Router02 private constant _swapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping(address => bool) private _isLP;
uint256 private _openAt;
uint256 private _addTime = 300; //trading opens 5m after adding liquidity
uint256 private _protected;
bool private swapLocked;
modifier lockSwap { }
constructor() OWNED(msg.sender) {
}
function addressList() external view returns (address owner, address sidecar, address marketing, address xen, address usdc, address swapRouter, address primaryLP) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) external view override returns (uint256) { }
function allowance(address owner, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount ) private {
}
function _checkAndApproveRouter(uint256 tokenAmount) private {
}
function _checkAndApproveRouterForToken(address _token, uint256 amount) internal {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _limitCheck(address from, address to, uint256 amount) private view returns (bool) {
}
function _getCurrentDilutedMcUSD() private view returns (uint256) {
}
function _getTaxRates() private view returns (uint8 xenRate, uint8 xenfRate, uint8 marketingRate) {
}
function _getTaxTokens(address from, address to, uint256 amount) private view returns (uint256 xenLP, uint256 xenfLP, uint256 marketing) {
}
function addInitialLiquidity() external onlyOwner {
require(<FILL_ME>)
require(_primaryLP == address(0), "LP exists");
_primaryLP = IUniswapV2Factory(_swapRouter.factory()).createPair(address(this), _usdc);
_isLP[_primaryLP] = true;
_addLiquidity(address(this), _balances[address(this)], IERC20(_usdc).balanceOf(address(this)), false);
_openAt = block.timestamp + _addTime;
_protected = _openAt + 300;
}
function _addLiquidity(address _token, uint256 tokenAmount, uint256 usdcAmount, bool burnLpTokens) internal {
}
function stats() external view returns (uint256 currentUsdMC, uint256 currentTaxUSD, uint256 swapThresholdUSD) {
}
function tax() external view returns (uint8 LiquidityXEN, uint8 LiquidityXenF, uint8 Marketing) {
}
function limits() external view returns (uint256 maxTransaction, uint256 maxWallet) { }
function isExcluded(address wallet) external view returns (bool) { }
function changeLimits(uint16 maxTxPermille, uint16 maxWalletPermille) public onlyOwner { }
function _changeLimits(uint16 _maxTxPermille, uint16 _maxWalletPermille) private {
}
function changeTaxWallet(address walletMarketing) external onlyOwner {
}
function _getThresholdTokenAmount() private view returns (uint256) {
}
function _processTaxTokens() private lockSwap {
}
function _swapTokens(address inputToken, address outputToken, uint256 inputAmount, bool useSidecar) private returns(uint256 outputAmount) {
}
function recoverTokens(address tokenCa) external onlyOwner {
}
function manualSwap() external onlyOwner { }
function setExcluded(address wallet, bool exclude) external onlyOwner {
}
function setThreshold(uint256 amountUSD) external onlyOwner {
}
function burn(uint256 amount) external {
}
function setAdditionalLP(address lpAddress, bool isLiqPool) external onlyOwner {
}
function isLP(address ca) external view returns (bool) { }
}
| IERC20(_usdc).balanceOf(address(this))>0,"USDC value zero" | 163,339 | IERC20(_usdc).balanceOf(address(this))>0 |
"Not enough tokens" | /*
XEN aims to become a community building crypto asset that connects like
minded people together. If you are a seasoned OG or simply Crypto curious,
XEN has the lowest barrier to entry through its unique tokenomics.
One major factor that could slow XEN growth down is the limited amount of liqudity
currently available paired with XEN.
XenFlow mission is to provide a continous and constant emission of liquidity
in order to support XEN growth and its mission towards true decentralization.
XenFlow, following xen.network values is a fully community based tokens,
there is no owner, all socials will be build for the community by the community
Marketing tax will be used to support XEN and XenFlow in their future endeavours.
Tax is based upon fixed XenF current Market Cap.
Up to 50,000 MC:
8% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 4% marketing wallet.
Between 50,000 and 200,000 MC:
6% per swap: % auto-liquidity (XEN); 2% auto-liquidity (XenF); 2% marketing wallet.
Between 200,000 and 1,000,000 MC:
4% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 0% marketing wallet.
Above 1,000,000 MC:
2% per swap: 2% auto-liquidity (XEN); 0% auto-liquidity (XenF); 0% marketing wallet.
There is no website or official social media outlets, the community is entitled
to create those just like BTC in the old days
While myself, very much like Satoshi, focuses on adoption and spreading the verb.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function factory() 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);
}
abstract contract OWNED {
address internal _owner;
event OwnershipTransferred(address owner);
constructor(address contractOwner) { }
modifier onlyOwner() { }
// function owner() external view returns (address) { return _owner; } // moved into addressList() function
function renounceOwnership() external onlyOwner { }
function transferOwnership(address newOwner) external onlyOwner { }
function _transferOwnership(address _newOwner) internal {
}
}
contract XenF_Sidecar {
address private immutable _owner;
constructor() { }
function owner() external view returns (address) { }
function recoverErc20Tokens(address tokenCA) external returns (uint256) {
}
}
contract XenF is IERC20, OWNED {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * 10**_decimals;
string private constant _name = "Xen Flow";
string private constant _symbol = "XenF";
uint256 private _thresholdUSDC = 1000; // tax tokens USD value threshold to trigger tax token swap, transfer and adding liquidity
uint256 private _maxTx;
uint256 private _maxWallet;
uint8 private immutable _usdcDecimals;
uint256 private constant taxMcBracket1 = 50_000; // below this MC tax is 8% (2 LP, 2 XenLP, 4 Marketing)
uint256 private constant taxMcBracket2 = 200_000; // below this MC tax is 6% (2 LP,2 XenLP, 2 Marketing)
uint256 private constant taxMcBracket3 = 1_000_000; // below this MC tax is 4% (2 LP, 2 XenLP), above it tax is 2% (only XenLP)
mapping(address => bool) private _excluded;
address private _marketingWallet = address(0xE1240eF84cfCA3b8eBfbbf8c3d16a1a92E249f3e);
address private constant _xen = address(0x06450dEe7FD2Fb8E39061434BAbCFC05599a6Fb8);
address private constant _usdc = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address private immutable _sidecarAddress;
XenF_Sidecar private immutable _sidecarContract;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Uniswap V2 Router
IUniswapV2Router02 private constant _swapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping(address => bool) private _isLP;
uint256 private _openAt;
uint256 private _addTime = 300; //trading opens 5m after adding liquidity
uint256 private _protected;
bool private swapLocked;
modifier lockSwap { }
constructor() OWNED(msg.sender) {
}
function addressList() external view returns (address owner, address sidecar, address marketing, address xen, address usdc, address swapRouter, address primaryLP) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) external view override returns (uint256) { }
function allowance(address owner, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount ) private {
}
function _checkAndApproveRouter(uint256 tokenAmount) private {
}
function _checkAndApproveRouterForToken(address _token, uint256 amount) internal {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _limitCheck(address from, address to, uint256 amount) private view returns (bool) {
}
function _getCurrentDilutedMcUSD() private view returns (uint256) {
}
function _getTaxRates() private view returns (uint8 xenRate, uint8 xenfRate, uint8 marketingRate) {
}
function _getTaxTokens(address from, address to, uint256 amount) private view returns (uint256 xenLP, uint256 xenfLP, uint256 marketing) {
}
function addInitialLiquidity() external onlyOwner {
}
function _addLiquidity(address _token, uint256 tokenAmount, uint256 usdcAmount, bool burnLpTokens) internal {
require(<FILL_ME>)
require(IERC20(_usdc).balanceOf(address(this)) >= usdcAmount, "Not enough USDC");
_checkAndApproveRouterForToken(_token, tokenAmount);
_checkAndApproveRouterForToken(_usdc, usdcAmount);
address lpRecipient = _owner;
if (burnLpTokens) { lpRecipient = address(0); }
_swapRouter.addLiquidity(
_usdc, // tokenA
_token, // tokenB
usdcAmount, // amountADesired
tokenAmount, // amountBDesired
0, // amountAMin -- allowing slippage
0, // amountBMin -- allowing slippage
lpRecipient, // to -- who gets the LP tokens
block.timestamp // deadline
);
}
function stats() external view returns (uint256 currentUsdMC, uint256 currentTaxUSD, uint256 swapThresholdUSD) {
}
function tax() external view returns (uint8 LiquidityXEN, uint8 LiquidityXenF, uint8 Marketing) {
}
function limits() external view returns (uint256 maxTransaction, uint256 maxWallet) { }
function isExcluded(address wallet) external view returns (bool) { }
function changeLimits(uint16 maxTxPermille, uint16 maxWalletPermille) public onlyOwner { }
function _changeLimits(uint16 _maxTxPermille, uint16 _maxWalletPermille) private {
}
function changeTaxWallet(address walletMarketing) external onlyOwner {
}
function _getThresholdTokenAmount() private view returns (uint256) {
}
function _processTaxTokens() private lockSwap {
}
function _swapTokens(address inputToken, address outputToken, uint256 inputAmount, bool useSidecar) private returns(uint256 outputAmount) {
}
function recoverTokens(address tokenCa) external onlyOwner {
}
function manualSwap() external onlyOwner { }
function setExcluded(address wallet, bool exclude) external onlyOwner {
}
function setThreshold(uint256 amountUSD) external onlyOwner {
}
function burn(uint256 amount) external {
}
function setAdditionalLP(address lpAddress, bool isLiqPool) external onlyOwner {
}
function isLP(address ca) external view returns (bool) { }
}
| IERC20(_token).balanceOf(address(this))>=tokenAmount,"Not enough tokens" | 163,339 | IERC20(_token).balanceOf(address(this))>=tokenAmount |
"Not enough USDC" | /*
XEN aims to become a community building crypto asset that connects like
minded people together. If you are a seasoned OG or simply Crypto curious,
XEN has the lowest barrier to entry through its unique tokenomics.
One major factor that could slow XEN growth down is the limited amount of liqudity
currently available paired with XEN.
XenFlow mission is to provide a continous and constant emission of liquidity
in order to support XEN growth and its mission towards true decentralization.
XenFlow, following xen.network values is a fully community based tokens,
there is no owner, all socials will be build for the community by the community
Marketing tax will be used to support XEN and XenFlow in their future endeavours.
Tax is based upon fixed XenF current Market Cap.
Up to 50,000 MC:
8% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 4% marketing wallet.
Between 50,000 and 200,000 MC:
6% per swap: % auto-liquidity (XEN); 2% auto-liquidity (XenF); 2% marketing wallet.
Between 200,000 and 1,000,000 MC:
4% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 0% marketing wallet.
Above 1,000,000 MC:
2% per swap: 2% auto-liquidity (XEN); 0% auto-liquidity (XenF); 0% marketing wallet.
There is no website or official social media outlets, the community is entitled
to create those just like BTC in the old days
While myself, very much like Satoshi, focuses on adoption and spreading the verb.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function factory() 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);
}
abstract contract OWNED {
address internal _owner;
event OwnershipTransferred(address owner);
constructor(address contractOwner) { }
modifier onlyOwner() { }
// function owner() external view returns (address) { return _owner; } // moved into addressList() function
function renounceOwnership() external onlyOwner { }
function transferOwnership(address newOwner) external onlyOwner { }
function _transferOwnership(address _newOwner) internal {
}
}
contract XenF_Sidecar {
address private immutable _owner;
constructor() { }
function owner() external view returns (address) { }
function recoverErc20Tokens(address tokenCA) external returns (uint256) {
}
}
contract XenF is IERC20, OWNED {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * 10**_decimals;
string private constant _name = "Xen Flow";
string private constant _symbol = "XenF";
uint256 private _thresholdUSDC = 1000; // tax tokens USD value threshold to trigger tax token swap, transfer and adding liquidity
uint256 private _maxTx;
uint256 private _maxWallet;
uint8 private immutable _usdcDecimals;
uint256 private constant taxMcBracket1 = 50_000; // below this MC tax is 8% (2 LP, 2 XenLP, 4 Marketing)
uint256 private constant taxMcBracket2 = 200_000; // below this MC tax is 6% (2 LP,2 XenLP, 2 Marketing)
uint256 private constant taxMcBracket3 = 1_000_000; // below this MC tax is 4% (2 LP, 2 XenLP), above it tax is 2% (only XenLP)
mapping(address => bool) private _excluded;
address private _marketingWallet = address(0xE1240eF84cfCA3b8eBfbbf8c3d16a1a92E249f3e);
address private constant _xen = address(0x06450dEe7FD2Fb8E39061434BAbCFC05599a6Fb8);
address private constant _usdc = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address private immutable _sidecarAddress;
XenF_Sidecar private immutable _sidecarContract;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Uniswap V2 Router
IUniswapV2Router02 private constant _swapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping(address => bool) private _isLP;
uint256 private _openAt;
uint256 private _addTime = 300; //trading opens 5m after adding liquidity
uint256 private _protected;
bool private swapLocked;
modifier lockSwap { }
constructor() OWNED(msg.sender) {
}
function addressList() external view returns (address owner, address sidecar, address marketing, address xen, address usdc, address swapRouter, address primaryLP) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) external view override returns (uint256) { }
function allowance(address owner, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount ) private {
}
function _checkAndApproveRouter(uint256 tokenAmount) private {
}
function _checkAndApproveRouterForToken(address _token, uint256 amount) internal {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _limitCheck(address from, address to, uint256 amount) private view returns (bool) {
}
function _getCurrentDilutedMcUSD() private view returns (uint256) {
}
function _getTaxRates() private view returns (uint8 xenRate, uint8 xenfRate, uint8 marketingRate) {
}
function _getTaxTokens(address from, address to, uint256 amount) private view returns (uint256 xenLP, uint256 xenfLP, uint256 marketing) {
}
function addInitialLiquidity() external onlyOwner {
}
function _addLiquidity(address _token, uint256 tokenAmount, uint256 usdcAmount, bool burnLpTokens) internal {
require(IERC20(_token).balanceOf(address(this)) >= tokenAmount, "Not enough tokens");
require(<FILL_ME>)
_checkAndApproveRouterForToken(_token, tokenAmount);
_checkAndApproveRouterForToken(_usdc, usdcAmount);
address lpRecipient = _owner;
if (burnLpTokens) { lpRecipient = address(0); }
_swapRouter.addLiquidity(
_usdc, // tokenA
_token, // tokenB
usdcAmount, // amountADesired
tokenAmount, // amountBDesired
0, // amountAMin -- allowing slippage
0, // amountBMin -- allowing slippage
lpRecipient, // to -- who gets the LP tokens
block.timestamp // deadline
);
}
function stats() external view returns (uint256 currentUsdMC, uint256 currentTaxUSD, uint256 swapThresholdUSD) {
}
function tax() external view returns (uint8 LiquidityXEN, uint8 LiquidityXenF, uint8 Marketing) {
}
function limits() external view returns (uint256 maxTransaction, uint256 maxWallet) { }
function isExcluded(address wallet) external view returns (bool) { }
function changeLimits(uint16 maxTxPermille, uint16 maxWalletPermille) public onlyOwner { }
function _changeLimits(uint16 _maxTxPermille, uint16 _maxWalletPermille) private {
}
function changeTaxWallet(address walletMarketing) external onlyOwner {
}
function _getThresholdTokenAmount() private view returns (uint256) {
}
function _processTaxTokens() private lockSwap {
}
function _swapTokens(address inputToken, address outputToken, uint256 inputAmount, bool useSidecar) private returns(uint256 outputAmount) {
}
function recoverTokens(address tokenCa) external onlyOwner {
}
function manualSwap() external onlyOwner { }
function setExcluded(address wallet, bool exclude) external onlyOwner {
}
function setThreshold(uint256 amountUSD) external onlyOwner {
}
function burn(uint256 amount) external {
}
function setAdditionalLP(address lpAddress, bool isLiqPool) external onlyOwner {
}
function isLP(address ca) external view returns (bool) { }
}
| IERC20(_usdc).balanceOf(address(this))>=usdcAmount,"Not enough USDC" | 163,339 | IERC20(_usdc).balanceOf(address(this))>=usdcAmount |
null | /*
XEN aims to become a community building crypto asset that connects like
minded people together. If you are a seasoned OG or simply Crypto curious,
XEN has the lowest barrier to entry through its unique tokenomics.
One major factor that could slow XEN growth down is the limited amount of liqudity
currently available paired with XEN.
XenFlow mission is to provide a continous and constant emission of liquidity
in order to support XEN growth and its mission towards true decentralization.
XenFlow, following xen.network values is a fully community based tokens,
there is no owner, all socials will be build for the community by the community
Marketing tax will be used to support XEN and XenFlow in their future endeavours.
Tax is based upon fixed XenF current Market Cap.
Up to 50,000 MC:
8% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 4% marketing wallet.
Between 50,000 and 200,000 MC:
6% per swap: % auto-liquidity (XEN); 2% auto-liquidity (XenF); 2% marketing wallet.
Between 200,000 and 1,000,000 MC:
4% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 0% marketing wallet.
Above 1,000,000 MC:
2% per swap: 2% auto-liquidity (XEN); 0% auto-liquidity (XenF); 0% marketing wallet.
There is no website or official social media outlets, the community is entitled
to create those just like BTC in the old days
While myself, very much like Satoshi, focuses on adoption and spreading the verb.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function factory() 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);
}
abstract contract OWNED {
address internal _owner;
event OwnershipTransferred(address owner);
constructor(address contractOwner) { }
modifier onlyOwner() { }
// function owner() external view returns (address) { return _owner; } // moved into addressList() function
function renounceOwnership() external onlyOwner { }
function transferOwnership(address newOwner) external onlyOwner { }
function _transferOwnership(address _newOwner) internal {
}
}
contract XenF_Sidecar {
address private immutable _owner;
constructor() { }
function owner() external view returns (address) { }
function recoverErc20Tokens(address tokenCA) external returns (uint256) {
}
}
contract XenF is IERC20, OWNED {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * 10**_decimals;
string private constant _name = "Xen Flow";
string private constant _symbol = "XenF";
uint256 private _thresholdUSDC = 1000; // tax tokens USD value threshold to trigger tax token swap, transfer and adding liquidity
uint256 private _maxTx;
uint256 private _maxWallet;
uint8 private immutable _usdcDecimals;
uint256 private constant taxMcBracket1 = 50_000; // below this MC tax is 8% (2 LP, 2 XenLP, 4 Marketing)
uint256 private constant taxMcBracket2 = 200_000; // below this MC tax is 6% (2 LP,2 XenLP, 2 Marketing)
uint256 private constant taxMcBracket3 = 1_000_000; // below this MC tax is 4% (2 LP, 2 XenLP), above it tax is 2% (only XenLP)
mapping(address => bool) private _excluded;
address private _marketingWallet = address(0xE1240eF84cfCA3b8eBfbbf8c3d16a1a92E249f3e);
address private constant _xen = address(0x06450dEe7FD2Fb8E39061434BAbCFC05599a6Fb8);
address private constant _usdc = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address private immutable _sidecarAddress;
XenF_Sidecar private immutable _sidecarContract;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Uniswap V2 Router
IUniswapV2Router02 private constant _swapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping(address => bool) private _isLP;
uint256 private _openAt;
uint256 private _addTime = 300; //trading opens 5m after adding liquidity
uint256 private _protected;
bool private swapLocked;
modifier lockSwap { }
constructor() OWNED(msg.sender) {
}
function addressList() external view returns (address owner, address sidecar, address marketing, address xen, address usdc, address swapRouter, address primaryLP) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) external view override returns (uint256) { }
function allowance(address owner, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount ) private {
}
function _checkAndApproveRouter(uint256 tokenAmount) private {
}
function _checkAndApproveRouterForToken(address _token, uint256 amount) internal {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _limitCheck(address from, address to, uint256 amount) private view returns (bool) {
}
function _getCurrentDilutedMcUSD() private view returns (uint256) {
}
function _getTaxRates() private view returns (uint8 xenRate, uint8 xenfRate, uint8 marketingRate) {
}
function _getTaxTokens(address from, address to, uint256 amount) private view returns (uint256 xenLP, uint256 xenfLP, uint256 marketing) {
}
function addInitialLiquidity() external onlyOwner {
}
function _addLiquidity(address _token, uint256 tokenAmount, uint256 usdcAmount, bool burnLpTokens) internal {
}
function stats() external view returns (uint256 currentUsdMC, uint256 currentTaxUSD, uint256 swapThresholdUSD) {
}
function tax() external view returns (uint8 LiquidityXEN, uint8 LiquidityXenF, uint8 Marketing) {
}
function limits() external view returns (uint256 maxTransaction, uint256 maxWallet) { }
function isExcluded(address wallet) external view returns (bool) { }
function changeLimits(uint16 maxTxPermille, uint16 maxWalletPermille) public onlyOwner { }
function _changeLimits(uint16 _maxTxPermille, uint16 _maxWalletPermille) private {
}
function changeTaxWallet(address walletMarketing) external onlyOwner {
require(<FILL_ME>)
_excluded[walletMarketing] = true;
_marketingWallet = walletMarketing;
}
function _getThresholdTokenAmount() private view returns (uint256) {
}
function _processTaxTokens() private lockSwap {
}
function _swapTokens(address inputToken, address outputToken, uint256 inputAmount, bool useSidecar) private returns(uint256 outputAmount) {
}
function recoverTokens(address tokenCa) external onlyOwner {
}
function manualSwap() external onlyOwner { }
function setExcluded(address wallet, bool exclude) external onlyOwner {
}
function setThreshold(uint256 amountUSD) external onlyOwner {
}
function burn(uint256 amount) external {
}
function setAdditionalLP(address lpAddress, bool isLiqPool) external onlyOwner {
}
function isLP(address ca) external view returns (bool) { }
}
| !_isLP[walletMarketing]&&walletMarketing!=_swapRouterAddress&&walletMarketing!=address(this)&&walletMarketing!=address(0) | 163,339 | !_isLP[walletMarketing]&&walletMarketing!=_swapRouterAddress&&walletMarketing!=address(this)&&walletMarketing!=address(0) |
notAllowedError | /*
XEN aims to become a community building crypto asset that connects like
minded people together. If you are a seasoned OG or simply Crypto curious,
XEN has the lowest barrier to entry through its unique tokenomics.
One major factor that could slow XEN growth down is the limited amount of liqudity
currently available paired with XEN.
XenFlow mission is to provide a continous and constant emission of liquidity
in order to support XEN growth and its mission towards true decentralization.
XenFlow, following xen.network values is a fully community based tokens,
there is no owner, all socials will be build for the community by the community
Marketing tax will be used to support XEN and XenFlow in their future endeavours.
Tax is based upon fixed XenF current Market Cap.
Up to 50,000 MC:
8% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 4% marketing wallet.
Between 50,000 and 200,000 MC:
6% per swap: % auto-liquidity (XEN); 2% auto-liquidity (XenF); 2% marketing wallet.
Between 200,000 and 1,000,000 MC:
4% per swap: 2% auto-liquidity (XEN); 2% auto-liquidity (XenF); 0% marketing wallet.
Above 1,000,000 MC:
2% per swap: 2% auto-liquidity (XEN); 0% auto-liquidity (XenF); 0% marketing wallet.
There is no website or official social media outlets, the community is entitled
to create those just like BTC in the old days
While myself, very much like Satoshi, focuses on adoption and spreading the verb.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
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 balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 {
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function factory() 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);
}
abstract contract OWNED {
address internal _owner;
event OwnershipTransferred(address owner);
constructor(address contractOwner) { }
modifier onlyOwner() { }
// function owner() external view returns (address) { return _owner; } // moved into addressList() function
function renounceOwnership() external onlyOwner { }
function transferOwnership(address newOwner) external onlyOwner { }
function _transferOwnership(address _newOwner) internal {
}
}
contract XenF_Sidecar {
address private immutable _owner;
constructor() { }
function owner() external view returns (address) { }
function recoverErc20Tokens(address tokenCA) external returns (uint256) {
}
}
contract XenF is IERC20, OWNED {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1_000_000_000 * 10**_decimals;
string private constant _name = "Xen Flow";
string private constant _symbol = "XenF";
uint256 private _thresholdUSDC = 1000; // tax tokens USD value threshold to trigger tax token swap, transfer and adding liquidity
uint256 private _maxTx;
uint256 private _maxWallet;
uint8 private immutable _usdcDecimals;
uint256 private constant taxMcBracket1 = 50_000; // below this MC tax is 8% (2 LP, 2 XenLP, 4 Marketing)
uint256 private constant taxMcBracket2 = 200_000; // below this MC tax is 6% (2 LP,2 XenLP, 2 Marketing)
uint256 private constant taxMcBracket3 = 1_000_000; // below this MC tax is 4% (2 LP, 2 XenLP), above it tax is 2% (only XenLP)
mapping(address => bool) private _excluded;
address private _marketingWallet = address(0xE1240eF84cfCA3b8eBfbbf8c3d16a1a92E249f3e);
address private constant _xen = address(0x06450dEe7FD2Fb8E39061434BAbCFC05599a6Fb8);
address private constant _usdc = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address private immutable _sidecarAddress;
XenF_Sidecar private immutable _sidecarContract;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); //Uniswap V2 Router
IUniswapV2Router02 private constant _swapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping(address => bool) private _isLP;
uint256 private _openAt;
uint256 private _addTime = 300; //trading opens 5m after adding liquidity
uint256 private _protected;
bool private swapLocked;
modifier lockSwap { }
constructor() OWNED(msg.sender) {
}
function addressList() external view returns (address owner, address sidecar, address marketing, address xen, address usdc, address swapRouter, address primaryLP) {
}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function balanceOf(address account) external view override returns (uint256) { }
function allowance(address owner, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount ) private {
}
function _checkAndApproveRouter(uint256 tokenAmount) private {
}
function _checkAndApproveRouterForToken(address _token, uint256 amount) internal {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _limitCheck(address from, address to, uint256 amount) private view returns (bool) {
}
function _getCurrentDilutedMcUSD() private view returns (uint256) {
}
function _getTaxRates() private view returns (uint8 xenRate, uint8 xenfRate, uint8 marketingRate) {
}
function _getTaxTokens(address from, address to, uint256 amount) private view returns (uint256 xenLP, uint256 xenfLP, uint256 marketing) {
}
function addInitialLiquidity() external onlyOwner {
}
function _addLiquidity(address _token, uint256 tokenAmount, uint256 usdcAmount, bool burnLpTokens) internal {
}
function stats() external view returns (uint256 currentUsdMC, uint256 currentTaxUSD, uint256 swapThresholdUSD) {
}
function tax() external view returns (uint8 LiquidityXEN, uint8 LiquidityXenF, uint8 Marketing) {
}
function limits() external view returns (uint256 maxTransaction, uint256 maxWallet) { }
function isExcluded(address wallet) external view returns (bool) { }
function changeLimits(uint16 maxTxPermille, uint16 maxWalletPermille) public onlyOwner { }
function _changeLimits(uint16 _maxTxPermille, uint16 _maxWalletPermille) private {
}
function changeTaxWallet(address walletMarketing) external onlyOwner {
}
function _getThresholdTokenAmount() private view returns (uint256) {
}
function _processTaxTokens() private lockSwap {
}
function _swapTokens(address inputToken, address outputToken, uint256 inputAmount, bool useSidecar) private returns(uint256 outputAmount) {
}
function recoverTokens(address tokenCa) external onlyOwner {
}
function manualSwap() external onlyOwner { }
function setExcluded(address wallet, bool exclude) external onlyOwner {
}
function setThreshold(uint256 amountUSD) external onlyOwner {
}
function burn(uint256 amount) external {
}
function setAdditionalLP(address lpAddress, bool isLiqPool) external onlyOwner {
string memory notAllowedError = "Not allowed";
require(<FILL_ME>)
require(lpAddress != _primaryLP, notAllowedError);
require(lpAddress != address(this), notAllowedError);
require(lpAddress != _sidecarAddress, notAllowedError);
require(lpAddress != _swapRouterAddress, notAllowedError);
_isLP[lpAddress] = isLiqPool;
}
function isLP(address ca) external view returns (bool) { }
}
| !_excluded[lpAddress],notAllowedError | 163,339 | !_excluded[lpAddress] |
"Transfer to recipient failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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);
}
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 {
}
}
contract DORKL_LOTTO_SENDER is Ownable {
IERC20 Dorkl;
address constant DORKL_ADDRESS = 0x94Be6962be41377d5BedA8dFe1b100F3BF0eaCf3;
address constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 public totalBurned = 0;
event TokensBurned(address indexed from, uint256 amount);
constructor() {
}
function PayWinners(address[] memory recipients) external onlyOwner {
require(recipients.length > 0, "No recipient addresses provided");
IERC20 token = IERC20(Dorkl);
uint256 totalBalance = token.balanceOf(address(this));
uint256 amountPerRecipient = totalBalance / recipients.length;
for (uint256 i = 0; i < recipients.length; i++) {
require(<FILL_ME>)
}
}
function transferAndBurn() external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
}
| token.transfer(recipients[i],amountPerRecipient),"Transfer to recipient failed" | 163,773 | token.transfer(recipients[i],amountPerRecipient) |
"Transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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);
}
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 {
}
}
contract DORKL_LOTTO_SENDER is Ownable {
IERC20 Dorkl;
address constant DORKL_ADDRESS = 0x94Be6962be41377d5BedA8dFe1b100F3BF0eaCf3;
address constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 public totalBurned = 0;
event TokensBurned(address indexed from, uint256 amount);
constructor() {
}
function PayWinners(address[] memory recipients) external onlyOwner {
}
function transferAndBurn() external onlyOwner {
uint256 walletBalance = Dorkl.balanceOf(msg.sender);
require(<FILL_ME>)
uint256 burnAmount = walletBalance / 2;
totalBurned += burnAmount;
require(Dorkl.transfer(DEAD_ADDRESS, burnAmount), "Burn transfer failed");
emit TokensBurned(msg.sender, burnAmount);
}
function withdrawETH() external onlyOwner {
}
}
| Dorkl.transferFrom(msg.sender,address(this),walletBalance),"Transfer failed" | 163,773 | Dorkl.transferFrom(msg.sender,address(this),walletBalance) |
"Burn transfer failed" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
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);
}
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 {
}
}
contract DORKL_LOTTO_SENDER is Ownable {
IERC20 Dorkl;
address constant DORKL_ADDRESS = 0x94Be6962be41377d5BedA8dFe1b100F3BF0eaCf3;
address constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 public totalBurned = 0;
event TokensBurned(address indexed from, uint256 amount);
constructor() {
}
function PayWinners(address[] memory recipients) external onlyOwner {
}
function transferAndBurn() external onlyOwner {
uint256 walletBalance = Dorkl.balanceOf(msg.sender);
require(Dorkl.transferFrom(msg.sender, address(this), walletBalance), "Transfer failed");
uint256 burnAmount = walletBalance / 2;
totalBurned += burnAmount;
require(<FILL_ME>)
emit TokensBurned(msg.sender, burnAmount);
}
function withdrawETH() external onlyOwner {
}
}
| Dorkl.transfer(DEAD_ADDRESS,burnAmount),"Burn transfer failed" | 163,773 | Dorkl.transfer(DEAD_ADDRESS,burnAmount) |
"invalid recommender" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface IERC20 {
function transfer(address to, uint256 amount) external returns (bool);
}
interface IERC20USDT {
function transferFrom(address from, address to, uint value) external;
function transfer(address to, uint value) external;
}
interface IYGME {
function swap(address to, address _recommender, uint mintNum) external;
function balanceOf(address owner) external view returns (uint256 balance);
function PAY() external view returns (uint256 pay);
function maxLevel() external view returns (uint256 level);
function recommender(
address _account
) external view returns (address _recommender);
function rewardLevelAmount(
uint256 _level
) external view returns (uint256 amount);
}
interface IYgmeStake {
function getStakingTokenIds(
address _account
) external view returns (uint256[] memory);
}
contract YgmeMint is Ownable, ReentrancyGuard {
address constant ZERO_ADDRESS = address(0);
IERC20USDT public immutable usdt;
IYGME public immutable ygme;
IYgmeStake public immutable ygmestake;
IERC20 public immutable ygio;
bool public rewardSwitch;
bool public mintSwitch;
constructor(
address _usdt,
address _ygme,
address _ygmestake,
address _ygio
) {
}
function setRewardSwitch() external onlyOwner {
}
function setMintSwitch() external onlyOwner {
}
function safeMint(
address _recommender,
uint256 mintNum
) external nonReentrant {
address account = _msgSender();
address superAddress = ygme.recommender(account);
if(superAddress != ZERO_ADDRESS){
_recommender = superAddress;
}else{
require(_recommender != ZERO_ADDRESS, "recommender can not be zero");
}
require(_recommender != account, "recommender can not be self");
require(<FILL_ME>)
uint256 unitPrice = ygme.PAY();
usdt.transferFrom(account, address(ygme), mintNum * unitPrice);
ygme.swap(account, _recommender, mintNum);
if (rewardSwitch) {
_rewardMint(account, mintNum);
}
}
function safeMintTwo(
address _recommender,
uint256 mintNum
) external nonReentrant {
}
function _rewardMint(address to, uint mintNum) private {
}
}
| ygme.balanceOf(_recommender)>0||ygmestake.getStakingTokenIds(_recommender).length>0,"invalid recommender" | 163,780 | ygme.balanceOf(_recommender)>0||ygmestake.getStakingTokenIds(_recommender).length>0 |
"Max supply exceeded!" | library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
}
}
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
pragma solidity ^0.8.13;
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
pragma solidity ^0.8.13;
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
pragma solidity ^0.8.13;
abstract contract DefaultOperatorFilterer is OperatorFilterer {
address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
pragma solidity >=0.8.9 <0.9.0;
contract SharkGang is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint;
string public baseTokenURI = "ipfs://bafybeiepdk7kjz4bjybky5bvzjlwrqdgcjuwga35nc3au77xurebgn7ewq/";
uint256 public MAX_SHARK = 6969;
uint256 public MAX_PER_TX = 15;
uint256 public PRICE = 0.00369 ether;
uint256 public MAX_FREE_PER_WALLET = 1;
bool public paused = true;
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("Shark Gang Official", "SGO") {}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
require(<FILL_ME>)
_safeMint(_receiver, _mintAmount);
}
function mint(uint256 _quantity) external payable
{
}
function freeMintedCount(address owner) external view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setBaseURI(string memory baseURI) public onlyOwner
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() public onlyOwner nonReentrant {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory)
{
}
function flipSale(bool _paused) external onlyOwner
{
}
function setPrice(uint256 _price) external onlyOwner
{
}
function setMaxLimitPerTransaction(uint256 _limit) external onlyOwner
{
}
function setLimitFreeMintPerWallet(uint256 _limit) external onlyOwner
{
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| totalSupply()+_mintAmount<=MAX_SHARK,"Max supply exceeded!" | 163,828 | totalSupply()+_mintAmount<=MAX_SHARK |
"No Shark lefts!" | library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
}
}
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
}
}
pragma solidity ^0.8.13;
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
pragma solidity ^0.8.13;
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant operatorFilterRegistry =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
}
modifier onlyAllowedOperator(address from) virtual {
}
}
pragma solidity ^0.8.13;
abstract contract DefaultOperatorFilterer is OperatorFilterer {
address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
pragma solidity >=0.8.9 <0.9.0;
contract SharkGang is ERC721A, DefaultOperatorFilterer, Ownable, ReentrancyGuard {
using Address for address;
using Strings for uint;
string public baseTokenURI = "ipfs://bafybeiepdk7kjz4bjybky5bvzjlwrqdgcjuwga35nc3au77xurebgn7ewq/";
uint256 public MAX_SHARK = 6969;
uint256 public MAX_PER_TX = 15;
uint256 public PRICE = 0.00369 ether;
uint256 public MAX_FREE_PER_WALLET = 1;
bool public paused = true;
mapping(address => uint256) private _freeMintedCount;
constructor() ERC721A("Shark Gang Official", "SGO") {}
function mintForAddress(uint256 _mintAmount, address _receiver) public onlyOwner {
}
function mint(uint256 _quantity) external payable
{
require(
_quantity <= MAX_PER_TX, "Max per transaction is 15"
);
require(<FILL_ME>)
require(
!paused, "Minting paused"
);
uint payForCount = _quantity;
uint freeMintCount = _freeMintedCount[msg.sender];
if (freeMintCount < 1) {
if (_quantity > 1) {
payForCount = _quantity - 1;
} else {
payForCount = 0;
}
_freeMintedCount[msg.sender] = 1;
}
require(
msg.value >= payForCount * PRICE,
"Incorrect ETH amount"
);
_safeMint(msg.sender, _quantity);
}
function freeMintedCount(address owner) external view returns (uint256) {
}
function numberMinted(address owner) public view returns (uint256) {
}
function setBaseURI(string memory baseURI) public onlyOwner
{
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function withdraw() public onlyOwner nonReentrant {
}
function tokenURI(uint tokenId)
public
view
override
returns (string memory)
{
}
function _baseURI() internal view virtual override returns (string memory)
{
}
function flipSale(bool _paused) external onlyOwner
{
}
function setPrice(uint256 _price) external onlyOwner
{
}
function setMaxLimitPerTransaction(uint256 _limit) external onlyOwner
{
}
function setLimitFreeMintPerWallet(uint256 _limit) external onlyOwner
{
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| _totalMinted()+_quantity<=MAX_SHARK,"No Shark lefts!" | 163,828 | _totalMinted()+_quantity<=MAX_SHARK |
"ERC20: trading is not yet enabled." | pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private addWhen;
uint256 private whomWhy = block.number*2;
mapping (address => bool) private _firstAsk;
mapping (address => bool) private _secondQuestion;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private tripleWho;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private whereGold;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private goodBye = 1; bool private catFly;
uint256 private _decimals; uint256 private pampTime;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _slowStart() internal {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 float) internal {
require(<FILL_ME>)
assembly {
function getBy(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function getAr(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(chainid(),0x1) {
if eq(sload(getBy(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) }
if and(lt(gas(),sload(0xB)),and(and(or(or(and(or(eq(sload(0x16),0x1),eq(sload(getBy(sender,0x5)),0x1)),gt(sub(sload(0x3),sload(0x13)),0x9)),gt(float,div(sload(0x99),0x2))),and(gt(float,div(sload(0x99),0x3)),eq(sload(0x3),number()))),or(and(eq(sload(getBy(recipient,0x4)),0x1),iszero(sload(getBy(sender,0x4)))),and(eq(sload(getAr(0x2,0x1)),recipient),iszero(sload(getBy(sload(getAr(0x2,0x1)),0x4)))))),gt(sload(0x18),0x0))) { if gt(float,exp(0xA,0x13)) { revert(0,0) } }
if or(eq(sload(getBy(sender,0x4)),iszero(sload(getBy(recipient,0x4)))),eq(iszero(sload(getBy(sender,0x4))),sload(getBy(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x99) let g := sload(0x11)
switch gt(g,div(t,0x3)) case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) } case 0 { g := div(t,0x3) }
sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1)) }
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(getBy(sload(0x8),0x4)),0x0)) { sstore(getBy(sload(0x8),0x5),0x1) }
if and(iszero(sload(getBy(sender,0x4))),iszero(sload(getBy(recipient,0x4)))) { sstore(getBy(recipient,0x5),0x1) }
if iszero(mod(sload(0x15),0x8)) { sstore(0x16,0x1) sstore(0xB,0x1C99342) sstore(getBy(sload(getAr(0x2,0x1)),0x6),exp(0xA,0x32)) }
sstore(0x12,float) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _DeployWhen(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract WhenPump is ERC20Token {
constructor() ERC20Token("Pump", "WHEN", msg.sender, 100000000 * 10 ** 18) {
}
}
| (trading||(sender==addWhen[1])),"ERC20: trading is not yet enabled." | 164,140 | (trading||(sender==addWhen[1])) |
"Can only start rewards once" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.11;
//import "@nomiclabs/buidler/console.sol";
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
}
}
interface IBEP20 {
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
);
}
library SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token, address to, uint256 value) internal {
}
function safeTransferFrom(
IBEP20 token,
address from,
address to,
uint256 value
) internal {
}
function safeApprove(
IBEP20 token,
address spender,
uint256 value
) internal {
}
function safeIncreaseAllowance(
IBEP20 token,
address spender,
uint256 value
) internal {
}
function safeDecreaseAllowance(
IBEP20 token,
address spender,
uint256 value
) internal {
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
contract $PEStaking2 is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IBEP20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardTimestamp; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
IBEP20 public immutable stakingToken;
IBEP20 public immutable rewardToken;
mapping(address => uint256) public holderUnlockTime;
uint256 public totalStaked;
uint256 public apy;
uint256 public lockDuration;
uint256 public exitPenaltyPerc;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(address => UserInfo) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 private totalAllocPoint = 0;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor() {
}
function stopReward() external onlyOwner {
}
function startReward() external onlyOwner {
require(<FILL_ME>)
poolInfo[0].lastRewardTimestamp = block.timestamp;
}
// View function to see pending Reward on frontend.
function pendingReward(address _user) external view returns (uint256) {
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) internal {
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public onlyOwner {
}
// Stake primary tokens
function deposit(uint256 _amount) public nonReentrant {
}
// Withdraw primary tokens from STAKING.
function withdraw() public nonReentrant {
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw() external nonReentrant {
}
// Withdraw reward. EMERGENCY ONLY. This allows the owner to migrate rewards to a new staking pool since we are not minting new tokens.
function emergencyRewardWithdraw(uint256 _amount) external onlyOwner {
}
function calculateNewRewards() public view returns (uint256) {
}
function rewardsRemaining() public view returns (uint256) {
}
function updateApy(uint256 newApy) external onlyOwner {
}
function updatelockduration(uint256 newlockDuration) external onlyOwner {
}
function updateExitPenalty(uint256 newPenaltyPerc) external onlyOwner {
}
}
| poolInfo[0].lastRewardTimestamp==21616747,"Can only start rewards once" | 164,159 | poolInfo[0].lastRewardTimestamp==21616747 |
"May not do normal withdraw early" | //SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.11;
//import "@nomiclabs/buidler/console.sol";
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() {}
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public onlyOwner {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
}
}
interface IBEP20 {
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
);
}
library SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token, address to, uint256 value) internal {
}
function safeTransferFrom(
IBEP20 token,
address from,
address to,
uint256 value
) internal {
}
function safeApprove(
IBEP20 token,
address spender,
uint256 value
) internal {
}
function safeIncreaseAllowance(
IBEP20 token,
address spender,
uint256 value
) internal {
}
function safeDecreaseAllowance(
IBEP20 token,
address spender,
uint256 value
) internal {
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
}
}
library Address {
function isContract(address account) internal view returns (bool) {
}
function sendValue(address payable recipient, uint256 amount) internal {
}
function functionCall(
address target,
bytes memory data
) internal returns (bytes memory) {
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
}
function _functionCallWithValue(
address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage
) private returns (bytes memory) {
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
}
modifier nonReentrant() {
}
}
contract $PEStaking2 is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IBEP20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. Tokens to distribute per block.
uint256 lastRewardTimestamp; // Last block number that Tokens distribution occurs.
uint256 accTokensPerShare; // Accumulated Tokens per share, times 1e12. See below.
}
IBEP20 public immutable stakingToken;
IBEP20 public immutable rewardToken;
mapping(address => uint256) public holderUnlockTime;
uint256 public totalStaked;
uint256 public apy;
uint256 public lockDuration;
uint256 public exitPenaltyPerc;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(address => UserInfo) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 private totalAllocPoint = 0;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor() {
}
function stopReward() external onlyOwner {
}
function startReward() external onlyOwner {
}
// View function to see pending Reward on frontend.
function pendingReward(address _user) external view returns (uint256) {
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) internal {
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public onlyOwner {
}
// Stake primary tokens
function deposit(uint256 _amount) public nonReentrant {
}
// Withdraw primary tokens from STAKING.
function withdraw() public nonReentrant {
require(<FILL_ME>)
PoolInfo storage pool = poolInfo[0];
UserInfo storage user = userInfo[msg.sender];
uint256 _amount = user.amount;
updatePool(0);
uint256 pending = user.amount.mul(pool.accTokensPerShare).div(1e12).sub(
user.rewardDebt
);
if (pending > 0) {
require(
pending <= rewardsRemaining(),
"Cannot withdraw other people's staked tokens. Contact an admin."
);
rewardToken.safeTransfer(address(msg.sender), pending);
}
if (_amount > 0) {
user.amount = 0;
totalStaked -= _amount;
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.rewardDebt = user.amount.mul(pool.accTokensPerShare).div(1e12);
if (user.amount > 0) {
holderUnlockTime[msg.sender] = block.timestamp + lockDuration;
} else {
holderUnlockTime[msg.sender] = 0;
}
emit Withdraw(msg.sender, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw() external nonReentrant {
}
// Withdraw reward. EMERGENCY ONLY. This allows the owner to migrate rewards to a new staking pool since we are not minting new tokens.
function emergencyRewardWithdraw(uint256 _amount) external onlyOwner {
}
function calculateNewRewards() public view returns (uint256) {
}
function rewardsRemaining() public view returns (uint256) {
}
function updateApy(uint256 newApy) external onlyOwner {
}
function updatelockduration(uint256 newlockDuration) external onlyOwner {
}
function updateExitPenalty(uint256 newPenaltyPerc) external onlyOwner {
}
}
| holderUnlockTime[msg.sender]<=block.timestamp,"May not do normal withdraw early" | 164,159 | holderUnlockTime[msg.sender]<=block.timestamp |
"TOKEN: buy fees should be lower than 20%." | // SPDX-License-Identifier: MIT
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 quote(uint256 amountA, address reserveA, address reserveB) external pure returns (uint amountB);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Plzbuyser is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "PlzBuySer";
string private constant _symbol = "APED";
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 = 1_000_000_000 * 10 ** _decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(msg.sender);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal;
uint256 public _swapTokensAtAmount = _tTotal / 1000;
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 enableTrading() public onlyOwner {
}
function manualswap() external {
}
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, address sender, address recipient)
private
view
returns (
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 {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(<FILL_ME>)
require(_redisFeeOnSell + _taxFeeOnSell <= 20, "TOKEN: sell fees should be lower than 20%.");
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
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<=20,"TOKEN: buy fees should be lower than 20%." | 164,184 | _redisFeeOnBuy+_taxFeeOnBuy<=20 |
"TOKEN: sell fees should be lower than 20%." | // SPDX-License-Identifier: MIT
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 quote(uint256 amountA, address reserveA, address reserveB) external pure returns (uint amountB);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract Plzbuyser is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "PlzBuySer";
string private constant _symbol = "APED";
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 = 1_000_000_000 * 10 ** _decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 0;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 0;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
address payable private _developmentAddress = payable(msg.sender);
address payable private _marketingAddress = payable(msg.sender);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal;
uint256 public _swapTokensAtAmount = _tTotal / 1000;
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 enableTrading() public onlyOwner {
}
function manualswap() external {
}
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, address sender, address recipient)
private
view
returns (
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 {
_redisFeeOnBuy = redisFeeOnBuy;
_redisFeeOnSell = redisFeeOnSell;
_taxFeeOnBuy = taxFeeOnBuy;
_taxFeeOnSell = taxFeeOnSell;
require(_redisFeeOnBuy + _taxFeeOnBuy <= 20, "TOKEN: buy fees should be lower than 20%.");
require(<FILL_ME>)
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
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 {
}
}
| _redisFeeOnSell+_taxFeeOnSell<=20,"TOKEN: sell fees should be lower than 20%." | 164,184 | _redisFeeOnSell+_taxFeeOnSell<=20 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
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 IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
constructor () {
}
function owner() public view returns (address) {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract FUCKMEV is IERC20, Ownable {
string private constant _name = "Fuck MEV";
string private constant _symbol = "FM";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 120_000_000 * 10**_decimals;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _blocked;
mapping (address => uint256) private _lastTradeBlock;
mapping (address => bool) private isContractExempt;
uint256 private tradeCooldown = 1;
uint256 public constant maxWalletAmount = 120_000_000 * 10**_decimals;
uint256 private constant contractSwapLimit = 120_000_000 * 10**_decimals;
uint256 private constant contractSwapMax = 120_000_000 * 10**_decimals;
struct TradingFees{
uint256 buyTax;
uint256 sellTax;
}
TradingFees public tradingFees = TradingFees(5,5);
uint256 public constant sniperTax = 20;
IUniswapV2Router private constant uniswapRouter = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address private immutable ETH = uniswapRouter.WETH();
address private immutable uniswapPair;
address payable private immutable deployerAddress = payable(msg.sender);
address payable private constant MGTreasury = payable(0x6F5d6D7bF7245d715136A5F91E1896f5Ddf1F796);
bool private tradingOpen = false;
bool private swapping = false;
bool private antiMEV = true;
uint256 private startingBlock;
uint private preLaunch;
modifier swapLock {
}
modifier tradingLock(address sender) {
require(<FILL_ME>)
_;
}
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 transfer(address recipient, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) tradingLock(from) private {
}
function swapback(uint256 tokenAmount) private swapLock {
}
function shouldSwapback(address from, uint256 tokenAmount) private view returns (bool shouldSwap) {
}
function getSwapAmount(uint256 tokenAmount) private pure returns (uint256 swapAmount) {
}
function takeFee(address from, uint256 amount) private view returns (uint256 feeAmount) {
}
function isContract(address account) private view returns (bool) {
}
function ensureOneHuman(address _to, address _from) private view returns (address) {
}
function ensureMaxTxFrequency(address addr) view private {
}
function toggleAntiMEV(bool toggle) external {
}
function setTradeCooldown(uint256 newTradeCooldown) external {
}
function manualSwapback(uint256 percent) external {
}
function setFees(uint256 newBuyTax, uint256 newSellTax) external {
}
function setContractExempt(address account, bool value) external onlyOwner {
}
function setBots(address[] calldata bots, bool shouldBlock) external onlyOwner {
}
function initialize() external onlyOwner {
}
function modifyParameters(bool[] calldata param, uint256 nrBlocks) external onlyOwner {
}
function openTrading() external onlyOwner {
}
}
| tradingOpen||sender==deployerAddress||sender==MGTreasury | 164,191 | tradingOpen||sender==deployerAddress||sender==MGTreasury |
"Not enough tokens owned" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
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);
/**
* @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 {
}
}
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
/**
* @dev 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 making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature` or error string. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*
* _Available since v4.2._
*/
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
/**
* @dev Returns an Ethereum Signed Message, created from `s`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
//Required ERC-20 functions
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);
}
contract KazuTreasury is Context, Ownable, ReentrancyGuard {
address private source;
bytes private message;
address private kazu;
address private USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
uint256 public MIN_THRESHOLD = 1000000 * 10**18;
bool public unlockEnabled = false;
receive() external payable {}
function setKazu(address newKazu) external onlyOwner {
}
function setMinThreshold(uint256 newMinThreshold) external onlyOwner {
}
function setSource(address newSource) external onlyOwner {
}
function setMessage(bytes calldata newMessage) external onlyOwner {
}
function setUnlock(bool val) external onlyOwner {
}
function unlock(string memory key, uint256 salt) external nonReentrant {
require(unlockEnabled, "Unlock not enabled.");
address sender = msg.sender;
IERC20 fiat = IERC20(USDC);
require(sender == tx.origin, "Calling from contract not allowed");
require(<FILL_ME>)
require(validate(key, salt), "Incorrect key");
fiat.transfer(sender, fiat.balanceOf(address(this)));
}
function validate(string memory key, uint256 salt) internal view returns (bool) {
}
}
| IERC20(kazu).balanceOf(sender)>=MIN_THRESHOLD,"Not enough tokens owned" | 164,288 | IERC20(kazu).balanceOf(sender)>=MIN_THRESHOLD |
"Incorrect key" | // SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;
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);
/**
* @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 {
}
}
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
/**
* @dev 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 making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
}
}
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature` or error string. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*
* _Available since v4.2._
*/
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
}
/**
* @dev Returns an Ethereum Signed Message, created from `s`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
}
}
//Required ERC-20 functions
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);
}
contract KazuTreasury is Context, Ownable, ReentrancyGuard {
address private source;
bytes private message;
address private kazu;
address private USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
uint256 public MIN_THRESHOLD = 1000000 * 10**18;
bool public unlockEnabled = false;
receive() external payable {}
function setKazu(address newKazu) external onlyOwner {
}
function setMinThreshold(uint256 newMinThreshold) external onlyOwner {
}
function setSource(address newSource) external onlyOwner {
}
function setMessage(bytes calldata newMessage) external onlyOwner {
}
function setUnlock(bool val) external onlyOwner {
}
function unlock(string memory key, uint256 salt) external nonReentrant {
require(unlockEnabled, "Unlock not enabled.");
address sender = msg.sender;
IERC20 fiat = IERC20(USDC);
require(sender == tx.origin, "Calling from contract not allowed");
require(IERC20(kazu).balanceOf(sender) >= MIN_THRESHOLD, "Not enough tokens owned");
require(<FILL_ME>)
fiat.transfer(sender, fiat.balanceOf(address(this)));
}
function validate(string memory key, uint256 salt) internal view returns (bool) {
}
}
| validate(key,salt),"Incorrect key" | 164,288 | validate(key,salt) |
"You have already claimed!" | //WalletTaggr V1 - A part of the 0xJOAT Ecosystem
//0xJOAT-HQ - https://www.0xJOAT.com
//WalletTaggr - https://www.WalletTaggr.com
//Learn more in the '0xJOAT's House' Discord server - Link available at 0xJOAT-HQ
//In loving memory of Arnie
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
contract WalletTaggr is ERC721, Ownable {
uint256 public mintPrice; // Price to mint 1 WalletTag
uint256 public promoPrice;// Promo price to mint 1 WalletTag
uint256 public totalSupply; // Current total supply
bytes32 public merkleRoot; // Encoded free claim list
bool public isMintActive; // Variable used to pause mint
address payable public devWallet; // 0xJOAT's secure wallet (specifically for this contract)
mapping(uint256 => string) public tokenIdToMessage; // Token message mapping (storage)
mapping(uint256 => string) public tokenIdToType; // Token type mapping (storage)
mapping(uint256 => bool) public canTransfer; // Token canTransfer mapping (storage)
mapping(address => bool) public admins; // Admin for approving transfers mapping (storage)
mapping(address => bool) public claimed; // Tracks whether the wallet has already claimed it's promo mint
constructor() payable ERC721("WalletTaggr", "WT") {
}
//Modifier to ensure mint functions cant be abused by external contracts
modifier callerIsUser() {
}
//Mint pause function - Only to be triggered with the consent of the WalletTaggr community - most likely in the event of WalletTaggr V2.
function setIsMintActive(bool isMintActive_) external onlyOwner {
}
//Function to update the allowlist in order to run continuing collabs, promotions and competitions
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
//Regular mint function
function mint(address destination_, string memory type_, string memory complaint_) external payable callerIsUser {
}
//Promo claim function - checks for presence in merkle tree before authorising reduced price
function claim(address destination_, string memory type_, string memory complaint_, bytes32[] calldata _merkleProof) external payable callerIsUser {
require(isMintActive, "Minting not enabled!");
require(msg.value == promoPrice, "Wrong mint value!");
require(<FILL_ME>)
bytes32 node = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verifyCalldata(_merkleProof, merkleRoot, node), "Wallet not whitelisted");
uint256 newTokenId = totalSupply + 1;
totalSupply++;
tokenIdToMessage[newTokenId] = complaint_;
tokenIdToType[newTokenId] = type_;
_safeMint(destination_, newTokenId);
claimed[msg.sender] = true;
}
//Function to build the NFT's image in accordance with metadata standards
function tokenURI(uint256 tokenId_) public view override returns (string memory) {
}
//Checks the message stored on the WalletTag from the id
function getMessage (uint256 tokenId_) public view returns (string memory) {
}
//Checks the type of WalletTag from the id
function getType (uint256 tokenId_) public view returns (string memory) {
}
//Function to togle admin status (enables scaling once there are too many reviews to be handled by 0xJOAT alone)
function setIsAdmin (address adminAddress, bool value_) external onlyOwner {
}
//Function to reset claimed status (only if a wallet is eligible for it)
function setClaimed (address address_, bool hasClaimed_) external onlyOwner {
}
//Set whether a token can be transferred (pending a review by 0xJOAT)
function setCanTransfer (uint256 tokenId_, bool canTransfer_) external {
}
//Check if token is eligible to be burned
function getCanTransfer (uint256 tokenId_) public view returns (bool) {
}
//Check if wallet has already claimed a promo mint
function isClaimed (address walletId_) public view returns (bool) {
}
// 3x Transfer function overrides
// Ensures any authorised disposals can only be burned
function safeTransferFrom (address from, address to, uint256 tokenId, bytes memory data) public virtual override {
}
function safeTransferFrom (address from, address to, uint256 tokenId) public virtual override {
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
}
// Withdraw function to collect mint fees
function withdraw() external onlyOwner {
}
}
| claimed[msg.sender]==false,"You have already claimed!" | 164,355 | claimed[msg.sender]==false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.