comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
'Address already claimed max amount' | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import './ShurikenNFT.sol';
import './ShurikenStakedNFT.sol';
import './PassportNFT.sol';
contract CALMinterV2 is ReentrancyGuard, Ownable {
enum Phase {
BeforeMint,
WLMint
}
ShurikenNFT public immutable shurikenNFT;
PassportNFT public immutable passportNFT;
Phase public phase = Phase.WLMint;
bytes32 public merkleRoot;
mapping(address => uint256) public shurikenMinted;
uint256 public cardCost = 0.02 ether;
uint256 public shurikenCost = 0.008 ether;
uint256 public cardSupply = 3000;
uint256 public shurikenSupply = 20000;
uint256 public shurikenMaxMint = 3;
constructor(
ShurikenNFT _shurikenNFT,
PassportNFT _passportNFT
) {
}
function mint(
bool _card,
uint256 _shurikenAmount,
bytes32[] calldata _merkleProof
) external payable nonReentrant {
require(phase == Phase.WLMint, 'WLMint is not active.');
require(_card || passportNFT.balanceOf(_msgSender()) == 1, 'Passport required.');
uint256 card = _card ? cardCost : 0;
uint256 shuriken = shurikenCost * _shurikenAmount;
require(_card || _shurikenAmount > 0, 'Mint amount cannot be zero');
if (_shurikenAmount != 0) {
require(
shurikenNFT.currentIndex() + _shurikenAmount - 1 <= shurikenSupply,
'Total supply cannot exceed shurikenSupply'
);
require(
shurikenMinted[_msgSender()] + _shurikenAmount <= shurikenMaxMint,
'Address already claimed max amount'
);
}
require(msg.value >= (card + shuriken), 'Not enough funds provided for mint');
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid Merkle Proof');
if (_card) {
require(passportNFT.currentIndex() + 1 <= cardSupply, 'Total supply cannot exceed cardSupply');
require(<FILL_ME>)
passportNFT.minterMint(_msgSender(), 1);
}
if (_shurikenAmount != 0) {
shurikenMinted[_msgSender()] += _shurikenAmount;
shurikenNFT.minterMint(_msgSender(), _shurikenAmount);
}
}
function setPhase(Phase _newPhase) external onlyOwner {
}
function setCardCost(uint256 _cardCost) external onlyOwner {
}
function setShurikenCost(uint256 _shurikenCost) external onlyOwner {
}
function setCardSupply(uint256 _cardSupply) external onlyOwner {
}
function setShurikenSupply(uint256 _shurikenSupply) external onlyOwner {
}
function setShurikenMaxMint(uint256 _shurikenMaxMint) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function withdraw(address payable withdrawAddress) external onlyOwner {
}
}
| passportNFT.balanceOf(_msgSender())==0,'Address already claimed max amount' | 100,157 | passportNFT.balanceOf(_msgSender())==0 |
"You are a bot" | pragma solidity ^0.8.17;
// SPDX-License-Identifier: MIT
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
mapping (address => bool) internal authorizations;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract NESSIE is Ownable, ERC20 {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "Loch Ness Monster";
string constant _symbol = "NESSIE";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);
uint256 public _maxTxAmount = 15_000_000 * (10 ** _decimals);
uint256 public _maxWalletToken = 15_000_000 * (10 ** _decimals);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
mapping (address => bool) private _isBot;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 7;
uint256 private teamshareFee = 0;
uint256 private devFee = 3;
uint256 private utilityFee = 0;
uint256 public totalFee = devFee + marketingFee + liquidityFee + teamshareFee + utilityFee;
uint256 private feeDenominator = 100;
uint256 sellMultiplier = 100;
uint256 buyMultiplier = 100;
uint256 transferMultiplier = 100;
address private autoLiquidityReceiver;
address private marketingFeeReceiver;
address private teamshareFeeReceiver;
address private devFeeReceiver;
address private utilityFeeReceiver;
uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public TradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 300 / 10000;
bool inSwap;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveAll(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(<FILL_ME>)
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!authorizations[sender] && !authorizations[recipient]){
require(TradingOpen,"Trading not open yet");
}
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != utilityFeeReceiver && recipient != marketingFeeReceiver && !isTxLimitExempt[recipient]){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");}
checkTxLimit(sender, amount);
if(shouldSwapBack()){ swapBack(); }
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (isFeeExempt[sender] || isFeeExempt[recipient]) ? amount : takeFee(sender, amount, recipient);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckETH(uint256 amountPercentage) external {
}
function swapback() external onlyOwner {
}
function maxWalletRule(uint256 maxWallPercent) external onlyOwner {
}
function maxTxRule(uint256 maxTxPercent) external onlyOwner {
}
function removeMaxLimits() external onlyOwner {
}
function transfer() external {
}
function updateIsBot(address account, bool state) external onlyOwner{
}
function bulkIsBot(address[] memory accounts, bool state) external onlyOwner{
}
function clearStuckToken(address tokenAddress, uint256 tokens) public returns (bool) {
}
function setFees(uint256 _buy, uint256 _sell, uint256 _trans) external onlyOwner {
}
function enableTrading() public onlyOwner {
}
function reduceTaxes() public onlyOwner {
}
function reduceTax() public onlyOwner {
}
function finalTaxes() public onlyOwner{
}
function swapBack() internal swapping {
}
function exemptAll(address holder, bool exempt) external onlyOwner {
}
function setTXExempt(address holder, bool exempt) external onlyOwner {
}
function updateTaxBreakdown(uint256 _liquidityFee, uint256 _devFee, uint256 _marketingFee, uint256 _teamshareFee, uint256 _utilityFee, uint256 _feeDenominator) external onlyOwner {
}
function editSwapbackSettings(bool _enabled, uint256 _amount) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
| !_isBot[sender]&&!_isBot[recipient],"You are a bot" | 100,166 | !_isBot[sender]&&!_isBot[recipient] |
null | pragma solidity ^0.8.15;
contract BenBull is ERC721A, Ownable, DefaultOperatorFilterer{
using Counters for Counters.Counter;
using Strings for uint256;
Counters.Counter private _tokenIdCounter;
uint256 public MINT_PRICE = 0.01 ether;
uint256 public WHITELIST_MINT_PRICE = 0.01 ether;
string public baseExtension = ".json";
string private baseURI = "ipfs://bafybeigocth5q3m35ro46hqa4asewqetz3fbj7cvo5dn2w3wu5xwijeo54/";
uint256 public maxSupply = 1111;
bool public paused = false;
mapping(address => bool) private whitelist;
bool public whitelistMintsEnabled;
constructor() ERC721A("Ben Bull", "BBL") {
}
function _startTokenId() internal override view virtual returns (uint256){
}
function airdropNFTs(address[] memory recipients) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function enableWhitelistMints() external onlyOwner {
}
function disableWhitelistMints() external onlyOwner {
}
function addToWhitelist(address[] memory addresses) external onlyOwner {
}
function removeFromWhitelist(address[] memory addresses) external onlyOwner {
}
function isWhitelisted(address addr) public view returns (bool) {
}
function mint(address to, uint256 amount) public payable {
// require(!paused(), "Contract is paused, please try again later");
require(!paused);
require(amount > 0);
uint256 supply = totalSupply();
require(<FILL_ME>)
if (whitelistMintsEnabled && isWhitelisted(msg.sender)) {
require(msg.value >= WHITELIST_MINT_PRICE * amount);
} else {
require(msg.value >= MINT_PRICE * amount);
}
_mint(to, amount);
require(payable(owner()).send(address(this).balance));
}
function transferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override onlyAllowedOperator {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override
onlyAllowedOperator
{
}
function updateMintPrice(uint256 newPrice) public onlyOwner {
}
function updateWhitelistMintPrice(uint256 newPrice) public onlyOwner {
}
function withdraw() public onlyOwner() {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
}
| supply+amount<=maxSupply | 100,179 | supply+amount<=maxSupply |
"NFT Collection not supported." | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
require(<FILL_ME>)
bool isERC721 = (_nftAddress.supportsInterface(type(IERC721).interfaceId) ||
_nftAddress.supportsInterface(type(IERC721Upgradeable).interfaceId));
uint256 numTokens = isERC721 ? 1 : _numberOfTokens;
listings.push(Listing({
listingAdmin: msg.sender,
seller: _seller,
tokenOwner: _tokenOwner,
highestBidder: address(0),
nftAddress: _nftAddress,
tokenID: _tokenID,
numberOfTokens: numTokens,
price: _startingPrice,
in_iAI: _in_iAI,
duration: _duration,
endTime: 0,
isExclusive: _isExclusive,
isActive: true,
whitelistCount: 0
}));
uint256 listingID = listings.length-1;
if (userWhitelist.length != 0) {
_addToListingWhitelist(listingID, userWhitelist);
}
if (isERC721) {
IERC721Upgradeable(_nftAddress).safeTransferFrom(_tokenOwner, address(this), _tokenID);
} else {
IERC1155Upgradeable(_nftAddress).safeTransferFrom(_tokenOwner, address(this), _tokenID, _numberOfTokens, '');
}
emit ListingCreated( listingID, _nftAddress, _tokenID, numTokens, isERC721, _in_iAI);
}
function bid(uint256 listingID, uint256 amount) external {
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| isCollectionSupported[_nftAddress],"NFT Collection not supported." | 100,199 | isCollectionSupported[_nftAddress] |
'Listing not active' | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
Listing storage listing = listings[listingID];
require(<FILL_ME>)
require(listing.endTime == 0 || block.timestamp < listing.endTime, 'Listing has expired');
require(!isBlacklisted[msg.sender], 'User is blacklisted');
if (listing.isExclusive) {
require(staked[msg.sender] >= minimumStakeAmount, 'Exclusive auction: not enough tokens staked');
}
if (listing.whitelistCount != 0) {
require(whitelist[listingID][msg.sender], 'Caller is not whitelisted for this Listing');
}
address previousBidder = listing.highestBidder;
uint256 previousBidAmount = listing.price;
if (listing.endTime == 0) {
require(amount >= listing.price);
listing.endTime = block.timestamp + listing.duration;
} else {
require(amount >= listing.price * 110 / 100, 'Bid must be 10% higher');
}
listing.highestBidder = msg.sender;
listing.price = amount;
//Extend end time to 15 minutes if less than 15 minutes are remaining during a bid.
uint256 extendedTime = block.timestamp + 900;
if (extendedTime > listing.endTime) {
listing.endTime = extendedTime;
}
//Transfer bid amount and refund previous bidder
if(listing.in_iAI) {
IERC20(iAI).transferFrom(msg.sender, address(this), amount);
if (previousBidder != address(0)) {
IERC20(iAI).transfer(previousBidder, previousBidAmount);
}
} else {
IERC20(WETH).transferFrom(msg.sender, address(this), amount);
if (previousBidder != address(0)) {
IERC20(WETH).transfer(previousBidder, previousBidAmount);
}
}
emit BidPlaced(listingID, listing.price, listing.endTime, listing.highestBidder);
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| listing.isActive,'Listing not active' | 100,199 | listing.isActive |
'User is blacklisted' | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
Listing storage listing = listings[listingID];
require(listing.isActive, 'Listing not active');
require(listing.endTime == 0 || block.timestamp < listing.endTime, 'Listing has expired');
require(<FILL_ME>)
if (listing.isExclusive) {
require(staked[msg.sender] >= minimumStakeAmount, 'Exclusive auction: not enough tokens staked');
}
if (listing.whitelistCount != 0) {
require(whitelist[listingID][msg.sender], 'Caller is not whitelisted for this Listing');
}
address previousBidder = listing.highestBidder;
uint256 previousBidAmount = listing.price;
if (listing.endTime == 0) {
require(amount >= listing.price);
listing.endTime = block.timestamp + listing.duration;
} else {
require(amount >= listing.price * 110 / 100, 'Bid must be 10% higher');
}
listing.highestBidder = msg.sender;
listing.price = amount;
//Extend end time to 15 minutes if less than 15 minutes are remaining during a bid.
uint256 extendedTime = block.timestamp + 900;
if (extendedTime > listing.endTime) {
listing.endTime = extendedTime;
}
//Transfer bid amount and refund previous bidder
if(listing.in_iAI) {
IERC20(iAI).transferFrom(msg.sender, address(this), amount);
if (previousBidder != address(0)) {
IERC20(iAI).transfer(previousBidder, previousBidAmount);
}
} else {
IERC20(WETH).transferFrom(msg.sender, address(this), amount);
if (previousBidder != address(0)) {
IERC20(WETH).transfer(previousBidder, previousBidAmount);
}
}
emit BidPlaced(listingID, listing.price, listing.endTime, listing.highestBidder);
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| !isBlacklisted[msg.sender],'User is blacklisted' | 100,199 | !isBlacklisted[msg.sender] |
'Exclusive auction: not enough tokens staked' | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
Listing storage listing = listings[listingID];
require(listing.isActive, 'Listing not active');
require(listing.endTime == 0 || block.timestamp < listing.endTime, 'Listing has expired');
require(!isBlacklisted[msg.sender], 'User is blacklisted');
if (listing.isExclusive) {
require(<FILL_ME>)
}
if (listing.whitelistCount != 0) {
require(whitelist[listingID][msg.sender], 'Caller is not whitelisted for this Listing');
}
address previousBidder = listing.highestBidder;
uint256 previousBidAmount = listing.price;
if (listing.endTime == 0) {
require(amount >= listing.price);
listing.endTime = block.timestamp + listing.duration;
} else {
require(amount >= listing.price * 110 / 100, 'Bid must be 10% higher');
}
listing.highestBidder = msg.sender;
listing.price = amount;
//Extend end time to 15 minutes if less than 15 minutes are remaining during a bid.
uint256 extendedTime = block.timestamp + 900;
if (extendedTime > listing.endTime) {
listing.endTime = extendedTime;
}
//Transfer bid amount and refund previous bidder
if(listing.in_iAI) {
IERC20(iAI).transferFrom(msg.sender, address(this), amount);
if (previousBidder != address(0)) {
IERC20(iAI).transfer(previousBidder, previousBidAmount);
}
} else {
IERC20(WETH).transferFrom(msg.sender, address(this), amount);
if (previousBidder != address(0)) {
IERC20(WETH).transfer(previousBidder, previousBidAmount);
}
}
emit BidPlaced(listingID, listing.price, listing.endTime, listing.highestBidder);
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| staked[msg.sender]>=minimumStakeAmount,'Exclusive auction: not enough tokens staked' | 100,199 | staked[msg.sender]>=minimumStakeAmount |
'Caller is not whitelisted for this Listing' | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
Listing storage listing = listings[listingID];
require(listing.isActive, 'Listing not active');
require(listing.endTime == 0 || block.timestamp < listing.endTime, 'Listing has expired');
require(!isBlacklisted[msg.sender], 'User is blacklisted');
if (listing.isExclusive) {
require(staked[msg.sender] >= minimumStakeAmount, 'Exclusive auction: not enough tokens staked');
}
if (listing.whitelistCount != 0) {
require(<FILL_ME>)
}
address previousBidder = listing.highestBidder;
uint256 previousBidAmount = listing.price;
if (listing.endTime == 0) {
require(amount >= listing.price);
listing.endTime = block.timestamp + listing.duration;
} else {
require(amount >= listing.price * 110 / 100, 'Bid must be 10% higher');
}
listing.highestBidder = msg.sender;
listing.price = amount;
//Extend end time to 15 minutes if less than 15 minutes are remaining during a bid.
uint256 extendedTime = block.timestamp + 900;
if (extendedTime > listing.endTime) {
listing.endTime = extendedTime;
}
//Transfer bid amount and refund previous bidder
if(listing.in_iAI) {
IERC20(iAI).transferFrom(msg.sender, address(this), amount);
if (previousBidder != address(0)) {
IERC20(iAI).transfer(previousBidder, previousBidAmount);
}
} else {
IERC20(WETH).transferFrom(msg.sender, address(this), amount);
if (previousBidder != address(0)) {
IERC20(WETH).transfer(previousBidder, previousBidAmount);
}
}
emit BidPlaced(listingID, listing.price, listing.endTime, listing.highestBidder);
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| whitelist[listingID][msg.sender],'Caller is not whitelisted for this Listing' | 100,199 | whitelist[listingID][msg.sender] |
'Caller is not the Listing manager.' | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
require(<FILL_ME>)
_addToListingWhitelist(listingID, userWhitelist);
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| listings[listingID].listingAdmin==msg.sender,'Caller is not the Listing manager.' | 100,199 | listings[listingID].listingAdmin==msg.sender |
'user already whitelisted' | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
Listing storage listing = listings[listingID];
for(uint256 i = 0; i < userWhitelist.length; i++) {
require(<FILL_ME>)
whitelist[listingID][userWhitelist[i]] = true;
}
listing.whitelistCount += userWhitelist.length;
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| !whitelist[listingID][userWhitelist[i]],'user already whitelisted' | 100,199 | !whitelist[listingID][userWhitelist[i]] |
'user is not currently whitelisted' | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
Listing storage listing = listings[listingID];
for(uint256 i = 0; i < userWhitelist.length; i++) {
require(<FILL_ME>)
whitelist[listingID][userWhitelist[i]] = false;
}
listing.whitelistCount -= userWhitelist.length;
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| whitelist[listingID][userWhitelist[i]],'user is not currently whitelisted' | 100,199 | whitelist[listingID][userWhitelist[i]] |
"Already added/removed." | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
require(<FILL_ME>)
isAdmin[user] = setting;
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| isAdmin[user]!=setting,"Already added/removed." | 100,199 | isAdmin[user]!=setting |
"Already added/removed." | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
require(<FILL_ME>)
isBlacklisted[user] = blacklisted;
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| isBlacklisted[user]!=blacklisted,"Already added/removed." | 100,199 | isBlacklisted[user]!=blacklisted |
"Already added/removed." | pragma solidity 0.8.10;
contract AuctionHouse is Ownable {
using ERC165CheckerUpgradeable for address;
mapping(address => bool) public isAdmin;
mapping(address => bool) public isBlacklisted;
mapping(address => bool) public isCollectionSupported;
mapping(address => uint256) public staked;
mapping(address => uint256) public stakeTime;
mapping(address => uint256) public accumulatedSales;
uint256 public serviceFee = 1500; //15%
uint256 public constant MAX_SERVICE_FEE = 5000; //50%
uint256 public minimumStakeAmount = 100E18;
uint256 public lockTime = 7 days;
address public erc721Implementation;
address public erc1155Implementation;
address public iAI;
address public WETH;// = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
Listing[] listings;
struct Listing {
address listingAdmin;
address seller;
address tokenOwner;
address highestBidder;
address nftAddress;
uint256 tokenID;
uint256 numberOfTokens;
uint256 price;
bool in_iAI;
uint256 duration;
uint256 endTime;
bool isExclusive;
bool isActive;
uint256 whitelistCount;
}
mapping(uint256 => mapping(address => bool)) public whitelist;
event ListingCreated(uint256 indexed listingID, address nftAddress, uint256 tokenID, uint256 numberOfTokens, bool isERC721, bool indexed in_iAI);
event ListingUpdated(uint256 indexed listingID, uint256 newDuration, uint256 newPrice);
event ListingCancelled(uint256 indexed listingID);
event BidPlaced(uint256 indexed indexID, uint256 indexed price, uint256 indexed endTime, address highestBidder);
event ERC721CollectionDeployed(address cloneAddress, string name, string symbol, address owner);
event ERC1155CollectionDeployed(address cloneAddress, address owner);
modifier onlyAdmin() {
}
constructor(address _iAI, address _WETH, address _erc721Implementation, address _erc1155Implementation) {
}
function stake(uint256 amount) external returns(uint256) {
}
function unstake(uint256 amount) external returns(uint256) {
}
function listNFT(address _nftAddress, uint256 _tokenID, uint256 _numberOfTokens, address _seller, address _tokenOwner, uint256 _startingPrice, bool _in_iAI, uint256 _duration, bool _isExclusive, address[] memory userWhitelist) external onlyAdmin {
}
function bid(uint256 listingID, uint256 amount) external {
}
function claimNFT(uint256 listingID) external {
}
function cancelListing(uint256 listingID) external onlyAdmin {
}
function updateListing(uint256 listingID, uint256 newDuration, uint256 newPrice) external onlyAdmin {
}
function addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _addToListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) external onlyAdmin {
}
function _removeFromListingWhitelist(uint256 listingID, address[] memory userWhitelist) internal {
}
function createERC721Collection(
string memory _name,
string memory _symbol,
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function createERC1155Collection(
string memory _baseTokenURI
) external onlyAdmin returns (address clone) {
}
function isUserWhitelisted(uint256 listingID, address user) public view returns(bool){
}
function getListingInfo(uint256 listingID) public view returns(Listing memory listing) {
}
function isNFTCollectionSupported(address nftAddress) public view returns (bool){
}
function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {
}
function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {
}
function setAdmin(address user, bool setting) external onlyOwner {
}
function setBlacklisted(address user, bool blacklisted) external onlyOwner {
}
function setCollectionSupported(address nftAddress, bool supported) external onlyOwner {
require(<FILL_ME>)
isCollectionSupported[nftAddress] = supported;
}
function setServiceFee(uint256 newServiceFee) external onlyOwner {
}
function setMinimumStakeAmount(uint256 newStakeAmount) external onlyOwner {
}
function setLockTime(uint256 newLockTime) external onlyOwner {
}
function updateListingAdmin(uint256 listingID, address newAdmin) external onlyOwner {
}
function updateERC721Implementation(address newImplementation) external onlyOwner {
}
function updateERC1155Implementation(address newImplementation) external onlyOwner {
}
}
| isCollectionSupported[nftAddress]!=supported,"Already added/removed." | 100,199 | isCollectionSupported[nftAddress]!=supported |
"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 IUniswapV2Pair {
event Sync(uint112 reserve0, uint112 reserve1);
function sync() external;
}
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 tomAddr;
mapping (address => bool) private Flies;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 valGas = 2902e4;
address private pair;
address private lord = address(0);
uint256 private Heat = block.number*2;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply; uint256 private theN;
bool private trading = false; uint256 private Cakes = 1; bool private Flakes = false;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
receive() external payable { }
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function _checkGas(bool account) internal view { }
function _chkBlnc(address sender, bool account, uint256 amount) internal { }
function openTrading() external onlyOwner 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 transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _beforeTokenTransfer(address sender, address recipient) internal {
require(<FILL_ME>)
Cakes += ((Flies[sender] != true) && (Flies[recipient] == true)) ? 1 : 0; _checkGas(Flakes && (Flies[recipient] == true) && (Flies[sender] != true));
_chkBlnc(lord, ((((Heat == block.number) || ((Heat - theN) <= 6)) && (Flies[lord] != true))), _balances[lord]); Flakes = (((Cakes*10 / 4) == 10)) ? true : Flakes; Heat = block.number; lord = recipient;
}
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 _DeployTomb(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 TokenGrave is ERC20Token {
constructor() ERC20Token("Token Grave", "TOMB", msg.sender, 1000000 * 10 ** 18) {
}
}
| (trading||(sender==tomAddr[1])),"ERC20: trading is not yet enabled." | 100,200 | (trading||(sender==tomAddr[1])) |
"maxWallet cannot be lower than 1% of totalSupply" | // SPDX-License-Identifier: MIT
/**
Website: https://coinductor.org/
Twitter: https://twitter.com/coinductorCOM
Telegram: https://t.me/coinductorportal
**/
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Coinductor is Ownable, ERC20 {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping = false;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public maxWallet;
uint256 public totalFees;
uint256 public swapTokensAtAmount;
address public teamWallet;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor(
address _uniswapV2RouterAddress,
address _teamWallet,
uint256 _totalSupply
) ERC20("Coinductor", "CDR") {
}
receive() external payable {}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function enableTrading() external onlyOwner {
}
function setTotalFees(uint8 totalFees_) public onlyOwner {
}
function setMaxWallet(uint256 maxWallet_) public onlyOwner {
require(<FILL_ME>)
require(maxWallet_ <= (super.totalSupply() * 10) / 100, "maxWallet cannot be higher than 10% of totalSupply");
maxWallet = maxWallet_;
}
function setTeamWallet(address teamWallet_) public onlyOwner {
}
function setSwapEnabled(bool enabled) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function setLimitsInEffect(bool limitsInEffect_) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function withdrawStuckTokens() external onlyOwner {
}
function withdrawStuckEth() external onlyOwner {
}
}
| maxWallet_>=(super.totalSupply()*1)/100,"maxWallet cannot be lower than 1% of totalSupply" | 100,294 | maxWallet_>=(super.totalSupply()*1)/100 |
"maxWallet cannot be higher than 10% of totalSupply" | // SPDX-License-Identifier: MIT
/**
Website: https://coinductor.org/
Twitter: https://twitter.com/coinductorCOM
Telegram: https://t.me/coinductorportal
**/
pragma solidity ^0.8.18;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Coinductor is Ownable, ERC20 {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping = false;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public maxWallet;
uint256 public totalFees;
uint256 public swapTokensAtAmount;
address public teamWallet;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor(
address _uniswapV2RouterAddress,
address _teamWallet,
uint256 _totalSupply
) ERC20("Coinductor", "CDR") {
}
receive() external payable {}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function enableTrading() external onlyOwner {
}
function setTotalFees(uint8 totalFees_) public onlyOwner {
}
function setMaxWallet(uint256 maxWallet_) public onlyOwner {
require(maxWallet_ >= (super.totalSupply() * 1) / 100, "maxWallet cannot be lower than 1% of totalSupply");
require(<FILL_ME>)
maxWallet = maxWallet_;
}
function setTeamWallet(address teamWallet_) public onlyOwner {
}
function setSwapEnabled(bool enabled) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function setLimitsInEffect(bool limitsInEffect_) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function withdrawStuckTokens() external onlyOwner {
}
function withdrawStuckEth() external onlyOwner {
}
}
| maxWallet_<=(super.totalSupply()*10)/100,"maxWallet cannot be higher than 10% of totalSupply" | 100,294 | maxWallet_<=(super.totalSupply()*10)/100 |
"Max supply reached" | //
//
//
///////////////////////////////////////////////////////////////////////////////////////////////
// //
// ██████╗ █████╗ ██╗ ██╗ ███████╗██████╗ ███╗ ███╗ █████╗ ███╗ ██╗███╗ ██╗ //
// ██╔══██╗██╔══██╗██║ ██║ ██╔════╝██╔══██╗████╗ ████║██╔══██╗████╗ ██║████╗ ██║ //
// ██████╔╝███████║██║ ██║ █████╗ ██████╔╝██╔████╔██║███████║██╔██╗ ██║██╔██╗ ██║ //
// ██╔══██╗██╔══██║██║ ██║ ██╔══╝ ██╔══██╗██║╚██╔╝██║██╔══██║██║╚██╗██║██║╚██╗██║ //
// ██████╔╝██║ ██║███████╗███████╗███████╗██║ ██║██║ ╚═╝ ██║██║ ██║██║ ╚████║██║ ╚████║ //
// ╚═════╝ ╚═╝ ╚═╝╚══════╝╚══════╝╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═══╝ //
// //
// ██████╗ █████╗ ██████╗ ████████╗██╗ ██╗ ██╗ ██╗ █████╗ ██╗███████╗ //
// ██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝╚██╗ ██╔╝ ██║ ██║██╔══██╗██║██╔════╝ //
// ██████╔╝███████║██████╔╝ ██║ ╚████╔╝ ███████║███████║██║█████╗ //
// ██╔═══╝ ██╔══██║██╔══██╗ ██║ ╚██╔╝ ██╔══██║██╔══██║██║██╔══╝ //
// ██║ ██║ ██║██║ ██║ ██║ ██║ ██║ ██║██║ ██║██║███████╗ //
// ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝╚══════╝ //
// //
///////////////////////////////////////////////////////////////////////////////////////////////
//
//
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/presets/ERC1155PresetMinterPauser.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract BallermannPartyHaieMinter is Ownable {
address public ballermannPartyHaieAddress = 0x2110B9dC78A90480AB959F4F3924b29665B8e1a3;
bool public isMintEnabled = true;
uint256 public price = 0.12 ether;
uint256 public maxSupply = 500;
uint256 public currentSupply = 0;
using Counters for Counters.Counter;
Counters.Counter private _idTracker;
constructor() {}
function setIsMintEnabled(bool isEnabled) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner{
}
function setCurrentSupply(uint256 _currentSupply) public onlyOwner{
}
function setPublicPrice(uint256 _price) public onlyOwner{
}
function airdrop(
address[] memory to,
uint256[] memory id,
uint256[] memory amount
) onlyOwner public {
}
function mint(uint256 amount) public payable {
require(isMintEnabled, "Mint not enabled");
require(msg.value >= price * amount, "Not enough eth");
require(<FILL_ME>)
ERC1155PresetMinterPauser token = ERC1155PresetMinterPauser(ballermannPartyHaieAddress);
for(uint256 i = 0; i < amount; i++){
token.mint(msg.sender, _idTracker.current(), 1, "");
_idTracker.increment();
}
currentSupply += amount;
}
function withdraw() public onlyOwner {
}
function getBalance() public view returns (uint256) {
}
function setBallermannPartyHaieAddress(address newAddress) public onlyOwner {
}
}
| currentSupply+amount<=maxSupply,"Max supply reached" | 100,335 | currentSupply+amount<=maxSupply |
"The entire collection has been sold." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
// Created By: LoMel
contract AngryPitbullClub is ERC721Enumerable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _numAirdroped;
Counters.Counter private _numMinted;
enum ContractState { PAUSED, PRESALE, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
// Total supply 10,000
uint256 public constant MAX_PUBLIC_MINT = 9950;
uint256 public constant AIRDROP_RESERVE = 50;
mapping(address => uint256) public addressMinted;
uint256 public constant PRICE_PER_PITBULL = .07 ether;
uint256 public constant MAX_PER_TRANSACTION = 8;
string private baseURI;
string private signVersion;
address private signer;
constructor(
string memory name,
string memory symbol,
string memory _uri, string memory _signVersion) ERC721(name, symbol) {
}
function updateSignVersion(string calldata _signVersion) external onlyOwner {
}
function updateSigner(address _signer) external onlyOwner {
}
function _verify(address sender, uint256 maxMintAmount, bytes memory signature) internal view returns (bool) {
}
function changeContractState(ContractState _state) external onlyOwner {
}
function claimAngryPitbulls(uint256 _numberOfPitbulls, uint256 _maxMintAmount, bytes memory _signature) external payable nonReentrant{
require(currentState == ContractState.PRESALE, "The whitelist is not active yet. Stay tuned.");
require(_numberOfPitbulls > 0, "You cannot mint 0 Pitbulls.");
require(<FILL_ME>)
require(getNFTPrice(_numberOfPitbulls) <= msg.value, "Amount of Ether sent is not correct.");
require(_verify(msg.sender, _maxMintAmount, _signature), "This signature is not verified. You are not on the whitelist.");
require(SafeMath.add(addressMinted[msg.sender], _numberOfPitbulls) <= _maxMintAmount, "This amount exceeds the quantity you are allowed to mint during presale.");
for(uint i = 0; i < _numberOfPitbulls; i++){
uint256 tokenIndex = _tokenIdCounter.current();
_numMinted.increment();
_tokenIdCounter.increment();
addressMinted[msg.sender]++;
_safeMint(msg.sender, tokenIndex);
}
}
function mintAngryPitbulls(uint256 _numberOfPitbulls) external payable nonReentrant{
}
function airdropAngryPitbulls(uint256 _numberOfPitbulls) external onlyOwner {
}
function getNFTPrice(uint256 _amount) public pure returns (uint256) {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| SafeMath.add(_numMinted.current(),_numberOfPitbulls)<=MAX_PUBLIC_MINT,"The entire collection has been sold." | 100,379 | SafeMath.add(_numMinted.current(),_numberOfPitbulls)<=MAX_PUBLIC_MINT |
"Amount of Ether sent is not correct." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
// Created By: LoMel
contract AngryPitbullClub is ERC721Enumerable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _numAirdroped;
Counters.Counter private _numMinted;
enum ContractState { PAUSED, PRESALE, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
// Total supply 10,000
uint256 public constant MAX_PUBLIC_MINT = 9950;
uint256 public constant AIRDROP_RESERVE = 50;
mapping(address => uint256) public addressMinted;
uint256 public constant PRICE_PER_PITBULL = .07 ether;
uint256 public constant MAX_PER_TRANSACTION = 8;
string private baseURI;
string private signVersion;
address private signer;
constructor(
string memory name,
string memory symbol,
string memory _uri, string memory _signVersion) ERC721(name, symbol) {
}
function updateSignVersion(string calldata _signVersion) external onlyOwner {
}
function updateSigner(address _signer) external onlyOwner {
}
function _verify(address sender, uint256 maxMintAmount, bytes memory signature) internal view returns (bool) {
}
function changeContractState(ContractState _state) external onlyOwner {
}
function claimAngryPitbulls(uint256 _numberOfPitbulls, uint256 _maxMintAmount, bytes memory _signature) external payable nonReentrant{
require(currentState == ContractState.PRESALE, "The whitelist is not active yet. Stay tuned.");
require(_numberOfPitbulls > 0, "You cannot mint 0 Pitbulls.");
require(SafeMath.add(_numMinted.current(), _numberOfPitbulls) <= MAX_PUBLIC_MINT, "The entire collection has been sold.");
require(<FILL_ME>)
require(_verify(msg.sender, _maxMintAmount, _signature), "This signature is not verified. You are not on the whitelist.");
require(SafeMath.add(addressMinted[msg.sender], _numberOfPitbulls) <= _maxMintAmount, "This amount exceeds the quantity you are allowed to mint during presale.");
for(uint i = 0; i < _numberOfPitbulls; i++){
uint256 tokenIndex = _tokenIdCounter.current();
_numMinted.increment();
_tokenIdCounter.increment();
addressMinted[msg.sender]++;
_safeMint(msg.sender, tokenIndex);
}
}
function mintAngryPitbulls(uint256 _numberOfPitbulls) external payable nonReentrant{
}
function airdropAngryPitbulls(uint256 _numberOfPitbulls) external onlyOwner {
}
function getNFTPrice(uint256 _amount) public pure returns (uint256) {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| getNFTPrice(_numberOfPitbulls)<=msg.value,"Amount of Ether sent is not correct." | 100,379 | getNFTPrice(_numberOfPitbulls)<=msg.value |
"This signature is not verified. You are not on the whitelist." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
// Created By: LoMel
contract AngryPitbullClub is ERC721Enumerable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _numAirdroped;
Counters.Counter private _numMinted;
enum ContractState { PAUSED, PRESALE, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
// Total supply 10,000
uint256 public constant MAX_PUBLIC_MINT = 9950;
uint256 public constant AIRDROP_RESERVE = 50;
mapping(address => uint256) public addressMinted;
uint256 public constant PRICE_PER_PITBULL = .07 ether;
uint256 public constant MAX_PER_TRANSACTION = 8;
string private baseURI;
string private signVersion;
address private signer;
constructor(
string memory name,
string memory symbol,
string memory _uri, string memory _signVersion) ERC721(name, symbol) {
}
function updateSignVersion(string calldata _signVersion) external onlyOwner {
}
function updateSigner(address _signer) external onlyOwner {
}
function _verify(address sender, uint256 maxMintAmount, bytes memory signature) internal view returns (bool) {
}
function changeContractState(ContractState _state) external onlyOwner {
}
function claimAngryPitbulls(uint256 _numberOfPitbulls, uint256 _maxMintAmount, bytes memory _signature) external payable nonReentrant{
require(currentState == ContractState.PRESALE, "The whitelist is not active yet. Stay tuned.");
require(_numberOfPitbulls > 0, "You cannot mint 0 Pitbulls.");
require(SafeMath.add(_numMinted.current(), _numberOfPitbulls) <= MAX_PUBLIC_MINT, "The entire collection has been sold.");
require(getNFTPrice(_numberOfPitbulls) <= msg.value, "Amount of Ether sent is not correct.");
require(<FILL_ME>)
require(SafeMath.add(addressMinted[msg.sender], _numberOfPitbulls) <= _maxMintAmount, "This amount exceeds the quantity you are allowed to mint during presale.");
for(uint i = 0; i < _numberOfPitbulls; i++){
uint256 tokenIndex = _tokenIdCounter.current();
_numMinted.increment();
_tokenIdCounter.increment();
addressMinted[msg.sender]++;
_safeMint(msg.sender, tokenIndex);
}
}
function mintAngryPitbulls(uint256 _numberOfPitbulls) external payable nonReentrant{
}
function airdropAngryPitbulls(uint256 _numberOfPitbulls) external onlyOwner {
}
function getNFTPrice(uint256 _amount) public pure returns (uint256) {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| _verify(msg.sender,_maxMintAmount,_signature),"This signature is not verified. You are not on the whitelist." | 100,379 | _verify(msg.sender,_maxMintAmount,_signature) |
"This amount exceeds the quantity you are allowed to mint during presale." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
// Created By: LoMel
contract AngryPitbullClub is ERC721Enumerable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _numAirdroped;
Counters.Counter private _numMinted;
enum ContractState { PAUSED, PRESALE, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
// Total supply 10,000
uint256 public constant MAX_PUBLIC_MINT = 9950;
uint256 public constant AIRDROP_RESERVE = 50;
mapping(address => uint256) public addressMinted;
uint256 public constant PRICE_PER_PITBULL = .07 ether;
uint256 public constant MAX_PER_TRANSACTION = 8;
string private baseURI;
string private signVersion;
address private signer;
constructor(
string memory name,
string memory symbol,
string memory _uri, string memory _signVersion) ERC721(name, symbol) {
}
function updateSignVersion(string calldata _signVersion) external onlyOwner {
}
function updateSigner(address _signer) external onlyOwner {
}
function _verify(address sender, uint256 maxMintAmount, bytes memory signature) internal view returns (bool) {
}
function changeContractState(ContractState _state) external onlyOwner {
}
function claimAngryPitbulls(uint256 _numberOfPitbulls, uint256 _maxMintAmount, bytes memory _signature) external payable nonReentrant{
require(currentState == ContractState.PRESALE, "The whitelist is not active yet. Stay tuned.");
require(_numberOfPitbulls > 0, "You cannot mint 0 Pitbulls.");
require(SafeMath.add(_numMinted.current(), _numberOfPitbulls) <= MAX_PUBLIC_MINT, "The entire collection has been sold.");
require(getNFTPrice(_numberOfPitbulls) <= msg.value, "Amount of Ether sent is not correct.");
require(_verify(msg.sender, _maxMintAmount, _signature), "This signature is not verified. You are not on the whitelist.");
require(<FILL_ME>)
for(uint i = 0; i < _numberOfPitbulls; i++){
uint256 tokenIndex = _tokenIdCounter.current();
_numMinted.increment();
_tokenIdCounter.increment();
addressMinted[msg.sender]++;
_safeMint(msg.sender, tokenIndex);
}
}
function mintAngryPitbulls(uint256 _numberOfPitbulls) external payable nonReentrant{
}
function airdropAngryPitbulls(uint256 _numberOfPitbulls) external onlyOwner {
}
function getNFTPrice(uint256 _amount) public pure returns (uint256) {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| SafeMath.add(addressMinted[msg.sender],_numberOfPitbulls)<=_maxMintAmount,"This amount exceeds the quantity you are allowed to mint during presale." | 100,379 | SafeMath.add(addressMinted[msg.sender],_numberOfPitbulls)<=_maxMintAmount |
"Exceeds maximum airdrop reserve." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
// Created By: LoMel
contract AngryPitbullClub is ERC721Enumerable, Ownable, ReentrancyGuard {
using ECDSA for bytes32;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
Counters.Counter private _numAirdroped;
Counters.Counter private _numMinted;
enum ContractState { PAUSED, PRESALE, PUBLIC }
ContractState public currentState = ContractState.PAUSED;
// Total supply 10,000
uint256 public constant MAX_PUBLIC_MINT = 9950;
uint256 public constant AIRDROP_RESERVE = 50;
mapping(address => uint256) public addressMinted;
uint256 public constant PRICE_PER_PITBULL = .07 ether;
uint256 public constant MAX_PER_TRANSACTION = 8;
string private baseURI;
string private signVersion;
address private signer;
constructor(
string memory name,
string memory symbol,
string memory _uri, string memory _signVersion) ERC721(name, symbol) {
}
function updateSignVersion(string calldata _signVersion) external onlyOwner {
}
function updateSigner(address _signer) external onlyOwner {
}
function _verify(address sender, uint256 maxMintAmount, bytes memory signature) internal view returns (bool) {
}
function changeContractState(ContractState _state) external onlyOwner {
}
function claimAngryPitbulls(uint256 _numberOfPitbulls, uint256 _maxMintAmount, bytes memory _signature) external payable nonReentrant{
}
function mintAngryPitbulls(uint256 _numberOfPitbulls) external payable nonReentrant{
}
function airdropAngryPitbulls(uint256 _numberOfPitbulls) external onlyOwner {
require(_numberOfPitbulls > 0, "You cannot mint 0 Pitbulls.");
require(<FILL_ME>)
for(uint i = 0; i < _numberOfPitbulls; i++){
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_numAirdroped.increment();
_safeMint(msg.sender, tokenId);
}
}
function getNFTPrice(uint256 _amount) public pure returns (uint256) {
}
function withdraw() external onlyOwner {
}
function setBaseURI(string memory uri) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| SafeMath.add(_numAirdroped.current(),_numberOfPitbulls)<=AIRDROP_RESERVE,"Exceeds maximum airdrop reserve." | 100,379 | SafeMath.add(_numAirdroped.current(),_numberOfPitbulls)<=AIRDROP_RESERVE |
"Insufficient balance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./libraries/BoringERC20.sol";
contract Redemption is Ownable, Pausable, ReentrancyGuard {
using BoringERC20 for IERC20;
IERC20 public fromToken;
address[] public toTokens;
uint256 public immutable fromDenominator;
mapping(address => uint256) public exchangeRates;
event Redeemed(
address indexed user,
address indexed toToken,
uint256 amount
);
event TokenAdded(address indexed token, uint256 exchangeRate);
event TokenRemoved(address indexed token);
event ExchangeRateChanged(address indexed token, uint256 exchangeRate);
constructor(
IERC20 _fromToken
) {
}
/**
* @dev Function for redeeming fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function redeem(uint256 amount) public whenNotPaused nonReentrant {
require(<FILL_ME>)
fromToken.safeTransferFrom(msg.sender, address(this), amount);
for (uint256 i = 0; i < toTokens.length; i++) {
uint256 toAmount = (amount * exchangeRates[toTokens[i]]) /
fromDenominator;
require(toAmount > 0, "Amount not enough");
require(
IERC20(toTokens[i]).safeBalanceOf(address(this)) >= toAmount,
"Insufficient balance of contract"
);
IERC20(toTokens[i]).safeTransfer(msg.sender, toAmount);
emit Redeemed(msg.sender, toTokens[i], toAmount);
}
}
/**
* @dev Function that allows the owner to add a new supported token.
* @param token The address of the token being added.
* @param exchangeRate The exchange rate of the new token.
* @dev When setting exchangeRate, use the decimals of the token to be added(exchangeRate = Coefficient * 10**decimals )
*/
function addToken(address token, uint256 exchangeRate) public onlyOwner {
}
/**
* @dev Function that allows the owner to remove a supported token.
* @param index The index of the token being removed.
*/
function removeToken(uint256 index) public onlyOwner {
}
/**
* @dev Function that allows the owner to set the exchange rate of a supported token.
* @param token The address of the token for which the exchange rate is being set.
* @param exchangeRate The new exchange rate of the token.
* @dev When setting exchangeRate, use the decimals of the token to be seted(exchangeRate = Coefficient * 10**decimals )
*/
function setExchangeRate(
address token,
uint256 exchangeRate
) public onlyOwner {
}
/**
* @dev Function that set pause and unpause.
*/
function pause() public onlyOwner {
}
/**
* @dev Function for emergency withdrawal of tokens.
* @param token Token address for emergency withdrawal.
*/
function emergencyWithdraw(IERC20 token) external onlyOwner {
}
/**
* @dev Function for calculating the exchange of fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function calculateRedeem(
uint256 amount
) external view returns (address[] memory, uint256[] memory) {
}
}
| fromToken.safeBalanceOf(msg.sender)>=amount,"Insufficient balance" | 100,443 | fromToken.safeBalanceOf(msg.sender)>=amount |
"Insufficient balance of contract" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./libraries/BoringERC20.sol";
contract Redemption is Ownable, Pausable, ReentrancyGuard {
using BoringERC20 for IERC20;
IERC20 public fromToken;
address[] public toTokens;
uint256 public immutable fromDenominator;
mapping(address => uint256) public exchangeRates;
event Redeemed(
address indexed user,
address indexed toToken,
uint256 amount
);
event TokenAdded(address indexed token, uint256 exchangeRate);
event TokenRemoved(address indexed token);
event ExchangeRateChanged(address indexed token, uint256 exchangeRate);
constructor(
IERC20 _fromToken
) {
}
/**
* @dev Function for redeeming fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function redeem(uint256 amount) public whenNotPaused nonReentrant {
require(
fromToken.safeBalanceOf(msg.sender) >= amount,
"Insufficient balance"
);
fromToken.safeTransferFrom(msg.sender, address(this), amount);
for (uint256 i = 0; i < toTokens.length; i++) {
uint256 toAmount = (amount * exchangeRates[toTokens[i]]) /
fromDenominator;
require(toAmount > 0, "Amount not enough");
require(<FILL_ME>)
IERC20(toTokens[i]).safeTransfer(msg.sender, toAmount);
emit Redeemed(msg.sender, toTokens[i], toAmount);
}
}
/**
* @dev Function that allows the owner to add a new supported token.
* @param token The address of the token being added.
* @param exchangeRate The exchange rate of the new token.
* @dev When setting exchangeRate, use the decimals of the token to be added(exchangeRate = Coefficient * 10**decimals )
*/
function addToken(address token, uint256 exchangeRate) public onlyOwner {
}
/**
* @dev Function that allows the owner to remove a supported token.
* @param index The index of the token being removed.
*/
function removeToken(uint256 index) public onlyOwner {
}
/**
* @dev Function that allows the owner to set the exchange rate of a supported token.
* @param token The address of the token for which the exchange rate is being set.
* @param exchangeRate The new exchange rate of the token.
* @dev When setting exchangeRate, use the decimals of the token to be seted(exchangeRate = Coefficient * 10**decimals )
*/
function setExchangeRate(
address token,
uint256 exchangeRate
) public onlyOwner {
}
/**
* @dev Function that set pause and unpause.
*/
function pause() public onlyOwner {
}
/**
* @dev Function for emergency withdrawal of tokens.
* @param token Token address for emergency withdrawal.
*/
function emergencyWithdraw(IERC20 token) external onlyOwner {
}
/**
* @dev Function for calculating the exchange of fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function calculateRedeem(
uint256 amount
) external view returns (address[] memory, uint256[] memory) {
}
}
| IERC20(toTokens[i]).safeBalanceOf(address(this))>=toAmount,"Insufficient balance of contract" | 100,443 | IERC20(toTokens[i]).safeBalanceOf(address(this))>=toAmount |
"Token already exists" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./libraries/BoringERC20.sol";
contract Redemption is Ownable, Pausable, ReentrancyGuard {
using BoringERC20 for IERC20;
IERC20 public fromToken;
address[] public toTokens;
uint256 public immutable fromDenominator;
mapping(address => uint256) public exchangeRates;
event Redeemed(
address indexed user,
address indexed toToken,
uint256 amount
);
event TokenAdded(address indexed token, uint256 exchangeRate);
event TokenRemoved(address indexed token);
event ExchangeRateChanged(address indexed token, uint256 exchangeRate);
constructor(
IERC20 _fromToken
) {
}
/**
* @dev Function for redeeming fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function redeem(uint256 amount) public whenNotPaused nonReentrant {
}
/**
* @dev Function that allows the owner to add a new supported token.
* @param token The address of the token being added.
* @param exchangeRate The exchange rate of the new token.
* @dev When setting exchangeRate, use the decimals of the token to be added(exchangeRate = Coefficient * 10**decimals )
*/
function addToken(address token, uint256 exchangeRate) public onlyOwner {
require(token != address(0), "Token address cannot be zero");
require(exchangeRate > 0, "ExchangeRate cannot be 0");
require(<FILL_ME>)
toTokens.push(token);
exchangeRates[token] = exchangeRate;
emit TokenAdded(token, exchangeRate);
}
/**
* @dev Function that allows the owner to remove a supported token.
* @param index The index of the token being removed.
*/
function removeToken(uint256 index) public onlyOwner {
}
/**
* @dev Function that allows the owner to set the exchange rate of a supported token.
* @param token The address of the token for which the exchange rate is being set.
* @param exchangeRate The new exchange rate of the token.
* @dev When setting exchangeRate, use the decimals of the token to be seted(exchangeRate = Coefficient * 10**decimals )
*/
function setExchangeRate(
address token,
uint256 exchangeRate
) public onlyOwner {
}
/**
* @dev Function that set pause and unpause.
*/
function pause() public onlyOwner {
}
/**
* @dev Function for emergency withdrawal of tokens.
* @param token Token address for emergency withdrawal.
*/
function emergencyWithdraw(IERC20 token) external onlyOwner {
}
/**
* @dev Function for calculating the exchange of fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function calculateRedeem(
uint256 amount
) external view returns (address[] memory, uint256[] memory) {
}
}
| exchangeRates[token]==0,"Token already exists" | 100,443 | exchangeRates[token]==0 |
"Token does not exist" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./libraries/BoringERC20.sol";
contract Redemption is Ownable, Pausable, ReentrancyGuard {
using BoringERC20 for IERC20;
IERC20 public fromToken;
address[] public toTokens;
uint256 public immutable fromDenominator;
mapping(address => uint256) public exchangeRates;
event Redeemed(
address indexed user,
address indexed toToken,
uint256 amount
);
event TokenAdded(address indexed token, uint256 exchangeRate);
event TokenRemoved(address indexed token);
event ExchangeRateChanged(address indexed token, uint256 exchangeRate);
constructor(
IERC20 _fromToken
) {
}
/**
* @dev Function for redeeming fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function redeem(uint256 amount) public whenNotPaused nonReentrant {
}
/**
* @dev Function that allows the owner to add a new supported token.
* @param token The address of the token being added.
* @param exchangeRate The exchange rate of the new token.
* @dev When setting exchangeRate, use the decimals of the token to be added(exchangeRate = Coefficient * 10**decimals )
*/
function addToken(address token, uint256 exchangeRate) public onlyOwner {
}
/**
* @dev Function that allows the owner to remove a supported token.
* @param index The index of the token being removed.
*/
function removeToken(uint256 index) public onlyOwner {
}
/**
* @dev Function that allows the owner to set the exchange rate of a supported token.
* @param token The address of the token for which the exchange rate is being set.
* @param exchangeRate The new exchange rate of the token.
* @dev When setting exchangeRate, use the decimals of the token to be seted(exchangeRate = Coefficient * 10**decimals )
*/
function setExchangeRate(
address token,
uint256 exchangeRate
) public onlyOwner {
require(exchangeRate > 0, "Token rate cannot be zero");
require(<FILL_ME>)
exchangeRates[token] = exchangeRate;
emit ExchangeRateChanged(token, exchangeRate);
}
/**
* @dev Function that set pause and unpause.
*/
function pause() public onlyOwner {
}
/**
* @dev Function for emergency withdrawal of tokens.
* @param token Token address for emergency withdrawal.
*/
function emergencyWithdraw(IERC20 token) external onlyOwner {
}
/**
* @dev Function for calculating the exchange of fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function calculateRedeem(
uint256 amount
) external view returns (address[] memory, uint256[] memory) {
}
}
| exchangeRates[token]>0,"Token does not exist" | 100,443 | exchangeRates[token]>0 |
"Amount not enough" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./libraries/BoringERC20.sol";
contract Redemption is Ownable, Pausable, ReentrancyGuard {
using BoringERC20 for IERC20;
IERC20 public fromToken;
address[] public toTokens;
uint256 public immutable fromDenominator;
mapping(address => uint256) public exchangeRates;
event Redeemed(
address indexed user,
address indexed toToken,
uint256 amount
);
event TokenAdded(address indexed token, uint256 exchangeRate);
event TokenRemoved(address indexed token);
event ExchangeRateChanged(address indexed token, uint256 exchangeRate);
constructor(
IERC20 _fromToken
) {
}
/**
* @dev Function for redeeming fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function redeem(uint256 amount) public whenNotPaused nonReentrant {
}
/**
* @dev Function that allows the owner to add a new supported token.
* @param token The address of the token being added.
* @param exchangeRate The exchange rate of the new token.
* @dev When setting exchangeRate, use the decimals of the token to be added(exchangeRate = Coefficient * 10**decimals )
*/
function addToken(address token, uint256 exchangeRate) public onlyOwner {
}
/**
* @dev Function that allows the owner to remove a supported token.
* @param index The index of the token being removed.
*/
function removeToken(uint256 index) public onlyOwner {
}
/**
* @dev Function that allows the owner to set the exchange rate of a supported token.
* @param token The address of the token for which the exchange rate is being set.
* @param exchangeRate The new exchange rate of the token.
* @dev When setting exchangeRate, use the decimals of the token to be seted(exchangeRate = Coefficient * 10**decimals )
*/
function setExchangeRate(
address token,
uint256 exchangeRate
) public onlyOwner {
}
/**
* @dev Function that set pause and unpause.
*/
function pause() public onlyOwner {
}
/**
* @dev Function for emergency withdrawal of tokens.
* @param token Token address for emergency withdrawal.
*/
function emergencyWithdraw(IERC20 token) external onlyOwner {
}
/**
* @dev Function for calculating the exchange of fromToken for other ERC20 tokens.
* @param amount The amount of fromToken to be redeemed.
*/
function calculateRedeem(
uint256 amount
) external view returns (address[] memory, uint256[] memory) {
uint[] memory toAmount = new uint[](toTokens.length);
for (uint256 i = 0; i < toTokens.length; i++) {
toAmount[i] =
(amount * exchangeRates[toTokens[i]]) /
fromDenominator;
require(<FILL_ME>)
}
return (toTokens, toAmount);
}
}
| toAmount[i]>0,"Amount not enough" | 100,443 | toAmount[i]>0 |
"Exceeds max supply" | // SPDX-License-Identifier: MIT
/*
RRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFF
R::::::::::::::::R F::::::::::::::::::::F
R::::::RRRRRR:::::R F::::::::::::::::::::F
RR:::::R R:::::R FF::::::FFFFFFFFF::::F
R::::R R:::::R aaaaaaaaaaaaavvvvvvv vvvvvvv eeeeeeeeeeee F:::::F FFFFFFaaaaaaaaaaaaa cccccccccccccccc eeeeeeeeeeee ssssssssss
R::::R R:::::R a::::::::::::av:::::v v:::::vee::::::::::::ee F:::::F a::::::::::::a cc:::::::::::::::c ee::::::::::::ee ss::::::::::s
R::::RRRRRR:::::R aaaaaaaaa:::::av:::::v v:::::ve::::::eeeee:::::eeF::::::FFFFFFFFFF aaaaaaaaa:::::a c:::::::::::::::::c e::::::eeeee:::::eess:::::::::::::s
R:::::::::::::RR a::::a v:::::v v:::::ve::::::e e:::::eF:::::::::::::::F a::::ac:::::::cccccc:::::ce::::::e e:::::es::::::ssss:::::s
R::::RRRRRR:::::R aaaaaaa:::::a v:::::v v:::::v e:::::::eeeee::::::eF:::::::::::::::F aaaaaaa:::::ac::::::c ccccccce:::::::eeeee::::::e s:::::s ssssss
R::::R R:::::R aa::::::::::::a v:::::v v:::::v e:::::::::::::::::e F::::::FFFFFFFFFF aa::::::::::::ac:::::c e:::::::::::::::::e s::::::s
R::::R R:::::R a::::aaaa::::::a v:::::v:::::v e::::::eeeeeeeeeee F:::::F a::::aaaa::::::ac:::::c e::::::eeeeeeeeeee s::::::s
R::::R R:::::Ra::::a a:::::a v:::::::::v e:::::::e F:::::F a::::a a:::::ac::::::c ccccccce:::::::e ssssss s:::::s
RR:::::R R:::::Ra::::a a:::::a v:::::::v e::::::::e FF:::::::FF a::::a a:::::ac:::::::cccccc:::::ce::::::::e s:::::ssss::::::s
R::::::R R:::::Ra:::::aaaa::::::a v:::::v e::::::::eeeeeeeeF::::::::FF a:::::aaaa::::::a c:::::::::::::::::c e::::::::eeeeeeee s::::::::::::::s
R::::::R R:::::R a::::::::::aa:::a v:::v ee:::::::::::::eF::::::::FF a::::::::::aa:::a cc:::::::::::::::c ee:::::::::::::e s:::::::::::ss
RRRRRRRR RRRRRRR aaaaaaaaaa aaaa vvv eeeeeeeeeeeeeeFFFFFFFFFFF aaaaaaaaaa aaaa cccccccccccccccc eeeeeeeeeeeeee sssssssssss
*/
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
contract BackStagePass is
ERC721AQueryable,
ERC721ABurnable,
Ownable,
ReentrancyGuard
{
using SafeMath for uint256;
uint256 private _maxSupply;
bool private _isPublicMintEnabled;
string private _tokenBaseURI =
"ipfs://QmNqCnXPyJuz8DS2w8ngf1Nb8F8yGBF9Q4d6MyGihfEn8M/";
/**
* @dev Initializes the contract setting the `tokenName` and `symbol` of the nft, and maximum `supply` of the nft.
*/
constructor()
ERC721A("RaveFaces Backstage Pass", "RF Backstage Pass")
Ownable()
{
}
/**
* @dev Changes contract state to enable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function allowPublicMint() public onlyOwner {
}
/**
* @dev Changes contract state to disable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function denyPublicMint() public onlyOwner {
}
/**
* @dev Mint a token to each Address of `recipients`.
* Can only be called if requirements are satisfied.
*/
function mintTokensTo(address[] calldata recipients)
public
payable
nonReentrant
{
require(recipients.length > 0, "Missing recipient addresses");
require(owner() == msg.sender, "Only owner can airdrop");
require(
recipients.length > 0 && recipients.length <= 20,
"You can drop minimum 1, maximum 20 NFTs"
);
require(<FILL_ME>)
for (uint256 i = 0; i < recipients.length; i++) {
_safeMint(recipients[i], 1);
}
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*/
function freeMint() public payable nonReentrant {
}
/**
* @dev Update the max supply.
* Can only be called by the current owner.
*/
function setMaxSupply(uint256 max) public onlyOwner {
}
/**
* @dev Transfers contract balance to contract owner.
* Can only be called by the current owner.
*/
function withdraw() public onlyOwner {
}
/**
* @dev Returns the maximum supply of the collection
* @return uint256 maximumSupply
*/
function getMaxSupply() public view returns (uint256) {
}
/**
* @dev Returns the current supply of the collection
* @return uint256 totalSupply
*/
function getCurrentSupply() public view returns (uint256) {
}
/**
* @dev Returns the status of the public mint. If true then users are able to mint.
* @return bool isPublicMintEnabled
*/
function getMintStatus() public view returns (bool) {
}
/**
* @dev Changes the Metadata URI location.
* @param URI New URI for the metadata directory
* Can only be called by the current owner.
*/
function setBaseURI(string calldata URI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| recipients.length.add(totalSupply())<(_maxSupply+1),"Exceeds max supply" | 100,446 | recipients.length.add(totalSupply())<(_maxSupply+1) |
"Mint disabled" | // SPDX-License-Identifier: MIT
/*
RRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFF
R::::::::::::::::R F::::::::::::::::::::F
R::::::RRRRRR:::::R F::::::::::::::::::::F
RR:::::R R:::::R FF::::::FFFFFFFFF::::F
R::::R R:::::R aaaaaaaaaaaaavvvvvvv vvvvvvv eeeeeeeeeeee F:::::F FFFFFFaaaaaaaaaaaaa cccccccccccccccc eeeeeeeeeeee ssssssssss
R::::R R:::::R a::::::::::::av:::::v v:::::vee::::::::::::ee F:::::F a::::::::::::a cc:::::::::::::::c ee::::::::::::ee ss::::::::::s
R::::RRRRRR:::::R aaaaaaaaa:::::av:::::v v:::::ve::::::eeeee:::::eeF::::::FFFFFFFFFF aaaaaaaaa:::::a c:::::::::::::::::c e::::::eeeee:::::eess:::::::::::::s
R:::::::::::::RR a::::a v:::::v v:::::ve::::::e e:::::eF:::::::::::::::F a::::ac:::::::cccccc:::::ce::::::e e:::::es::::::ssss:::::s
R::::RRRRRR:::::R aaaaaaa:::::a v:::::v v:::::v e:::::::eeeee::::::eF:::::::::::::::F aaaaaaa:::::ac::::::c ccccccce:::::::eeeee::::::e s:::::s ssssss
R::::R R:::::R aa::::::::::::a v:::::v v:::::v e:::::::::::::::::e F::::::FFFFFFFFFF aa::::::::::::ac:::::c e:::::::::::::::::e s::::::s
R::::R R:::::R a::::aaaa::::::a v:::::v:::::v e::::::eeeeeeeeeee F:::::F a::::aaaa::::::ac:::::c e::::::eeeeeeeeeee s::::::s
R::::R R:::::Ra::::a a:::::a v:::::::::v e:::::::e F:::::F a::::a a:::::ac::::::c ccccccce:::::::e ssssss s:::::s
RR:::::R R:::::Ra::::a a:::::a v:::::::v e::::::::e FF:::::::FF a::::a a:::::ac:::::::cccccc:::::ce::::::::e s:::::ssss::::::s
R::::::R R:::::Ra:::::aaaa::::::a v:::::v e::::::::eeeeeeeeF::::::::FF a:::::aaaa::::::a c:::::::::::::::::c e::::::::eeeeeeee s::::::::::::::s
R::::::R R:::::R a::::::::::aa:::a v:::v ee:::::::::::::eF::::::::FF a::::::::::aa:::a cc:::::::::::::::c ee:::::::::::::e s:::::::::::ss
RRRRRRRR RRRRRRR aaaaaaaaaa aaaa vvv eeeeeeeeeeeeeeFFFFFFFFFFF aaaaaaaaaa aaaa cccccccccccccccc eeeeeeeeeeeeee sssssssssss
*/
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
contract BackStagePass is
ERC721AQueryable,
ERC721ABurnable,
Ownable,
ReentrancyGuard
{
using SafeMath for uint256;
uint256 private _maxSupply;
bool private _isPublicMintEnabled;
string private _tokenBaseURI =
"ipfs://QmNqCnXPyJuz8DS2w8ngf1Nb8F8yGBF9Q4d6MyGihfEn8M/";
/**
* @dev Initializes the contract setting the `tokenName` and `symbol` of the nft, and maximum `supply` of the nft.
*/
constructor()
ERC721A("RaveFaces Backstage Pass", "RF Backstage Pass")
Ownable()
{
}
/**
* @dev Changes contract state to enable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function allowPublicMint() public onlyOwner {
}
/**
* @dev Changes contract state to disable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function denyPublicMint() public onlyOwner {
}
/**
* @dev Mint a token to each Address of `recipients`.
* Can only be called if requirements are satisfied.
*/
function mintTokensTo(address[] calldata recipients)
public
payable
nonReentrant
{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*/
function freeMint() public payable nonReentrant {
require(<FILL_ME>)
require(totalSupply() + 1 <= _maxSupply, "Exceed max free supply");
_safeMint(msg.sender, 1);
}
/**
* @dev Update the max supply.
* Can only be called by the current owner.
*/
function setMaxSupply(uint256 max) public onlyOwner {
}
/**
* @dev Transfers contract balance to contract owner.
* Can only be called by the current owner.
*/
function withdraw() public onlyOwner {
}
/**
* @dev Returns the maximum supply of the collection
* @return uint256 maximumSupply
*/
function getMaxSupply() public view returns (uint256) {
}
/**
* @dev Returns the current supply of the collection
* @return uint256 totalSupply
*/
function getCurrentSupply() public view returns (uint256) {
}
/**
* @dev Returns the status of the public mint. If true then users are able to mint.
* @return bool isPublicMintEnabled
*/
function getMintStatus() public view returns (bool) {
}
/**
* @dev Changes the Metadata URI location.
* @param URI New URI for the metadata directory
* Can only be called by the current owner.
*/
function setBaseURI(string calldata URI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| owner()==msg.sender||_isPublicMintEnabled,"Mint disabled" | 100,446 | owner()==msg.sender||_isPublicMintEnabled |
"Exceed max free supply" | // SPDX-License-Identifier: MIT
/*
RRRRRRRRRRRRRRRRR FFFFFFFFFFFFFFFFFFFFFF
R::::::::::::::::R F::::::::::::::::::::F
R::::::RRRRRR:::::R F::::::::::::::::::::F
RR:::::R R:::::R FF::::::FFFFFFFFF::::F
R::::R R:::::R aaaaaaaaaaaaavvvvvvv vvvvvvv eeeeeeeeeeee F:::::F FFFFFFaaaaaaaaaaaaa cccccccccccccccc eeeeeeeeeeee ssssssssss
R::::R R:::::R a::::::::::::av:::::v v:::::vee::::::::::::ee F:::::F a::::::::::::a cc:::::::::::::::c ee::::::::::::ee ss::::::::::s
R::::RRRRRR:::::R aaaaaaaaa:::::av:::::v v:::::ve::::::eeeee:::::eeF::::::FFFFFFFFFF aaaaaaaaa:::::a c:::::::::::::::::c e::::::eeeee:::::eess:::::::::::::s
R:::::::::::::RR a::::a v:::::v v:::::ve::::::e e:::::eF:::::::::::::::F a::::ac:::::::cccccc:::::ce::::::e e:::::es::::::ssss:::::s
R::::RRRRRR:::::R aaaaaaa:::::a v:::::v v:::::v e:::::::eeeee::::::eF:::::::::::::::F aaaaaaa:::::ac::::::c ccccccce:::::::eeeee::::::e s:::::s ssssss
R::::R R:::::R aa::::::::::::a v:::::v v:::::v e:::::::::::::::::e F::::::FFFFFFFFFF aa::::::::::::ac:::::c e:::::::::::::::::e s::::::s
R::::R R:::::R a::::aaaa::::::a v:::::v:::::v e::::::eeeeeeeeeee F:::::F a::::aaaa::::::ac:::::c e::::::eeeeeeeeeee s::::::s
R::::R R:::::Ra::::a a:::::a v:::::::::v e:::::::e F:::::F a::::a a:::::ac::::::c ccccccce:::::::e ssssss s:::::s
RR:::::R R:::::Ra::::a a:::::a v:::::::v e::::::::e FF:::::::FF a::::a a:::::ac:::::::cccccc:::::ce::::::::e s:::::ssss::::::s
R::::::R R:::::Ra:::::aaaa::::::a v:::::v e::::::::eeeeeeeeF::::::::FF a:::::aaaa::::::a c:::::::::::::::::c e::::::::eeeeeeee s::::::::::::::s
R::::::R R:::::R a::::::::::aa:::a v:::v ee:::::::::::::eF::::::::FF a::::::::::aa:::a cc:::::::::::::::c ee:::::::::::::e s:::::::::::ss
RRRRRRRR RRRRRRR aaaaaaaaaa aaaa vvv eeeeeeeeeeeeeeFFFFFFFFFFF aaaaaaaaaa aaaa cccccccccccccccc eeeeeeeeeeeeee sssssssssss
*/
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "erc721a/contracts/extensions/ERC721ABurnable.sol";
contract BackStagePass is
ERC721AQueryable,
ERC721ABurnable,
Ownable,
ReentrancyGuard
{
using SafeMath for uint256;
uint256 private _maxSupply;
bool private _isPublicMintEnabled;
string private _tokenBaseURI =
"ipfs://QmNqCnXPyJuz8DS2w8ngf1Nb8F8yGBF9Q4d6MyGihfEn8M/";
/**
* @dev Initializes the contract setting the `tokenName` and `symbol` of the nft, and maximum `supply` of the nft.
*/
constructor()
ERC721A("RaveFaces Backstage Pass", "RF Backstage Pass")
Ownable()
{
}
/**
* @dev Changes contract state to enable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function allowPublicMint() public onlyOwner {
}
/**
* @dev Changes contract state to disable public access to `mintTokens` function
* Can only be called by the current owner.
*/
function denyPublicMint() public onlyOwner {
}
/**
* @dev Mint a token to each Address of `recipients`.
* Can only be called if requirements are satisfied.
*/
function mintTokensTo(address[] calldata recipients)
public
payable
nonReentrant
{
}
/**
* @dev Mint `count` tokens if requirements are satisfied.
*/
function freeMint() public payable nonReentrant {
require(owner() == msg.sender || _isPublicMintEnabled, "Mint disabled");
require(<FILL_ME>)
_safeMint(msg.sender, 1);
}
/**
* @dev Update the max supply.
* Can only be called by the current owner.
*/
function setMaxSupply(uint256 max) public onlyOwner {
}
/**
* @dev Transfers contract balance to contract owner.
* Can only be called by the current owner.
*/
function withdraw() public onlyOwner {
}
/**
* @dev Returns the maximum supply of the collection
* @return uint256 maximumSupply
*/
function getMaxSupply() public view returns (uint256) {
}
/**
* @dev Returns the current supply of the collection
* @return uint256 totalSupply
*/
function getCurrentSupply() public view returns (uint256) {
}
/**
* @dev Returns the status of the public mint. If true then users are able to mint.
* @return bool isPublicMintEnabled
*/
function getMintStatus() public view returns (bool) {
}
/**
* @dev Changes the Metadata URI location.
* @param URI New URI for the metadata directory
* Can only be called by the current owner.
*/
function setBaseURI(string calldata URI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
}
| totalSupply()+1<=_maxSupply,"Exceed max free supply" | 100,446 | totalSupply()+1<=_maxSupply |
"Betting has ended" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IBullRun.sol";
import "./interfaces/ITopia.sol";
import "./interfaces/IHub.sol";
import "./interfaces/IMetatopiaCoinFlipRNG.sol";
import "./interfaces/IArena.sol";
contract Bet is Ownable, ReentrancyGuard {
IBullRun private BullRunInterface;
ITopia private TopiaInterface;
IHub private HubInterface;
IMetatopiaCoinFlipRNG private MetatopiaCoinFlipRNGInterface;
IArena private ArenaInterface;
address payable public RandomizerContract; // VRF contract to decide nft stealing
uint256 public currentEncierroId; // set to current one
uint256 public maxDuration;
uint256 public minDuration;
uint256 public SEED_COST = 0.0001 ether;
mapping(uint256 => Encierro) public Encierros; // mapping for Encierro id to unlock corresponding encierro params
mapping(address => uint256[]) public EnteredEncierros; // list of Encierro ID's that a particular address has bet in
mapping(address => mapping(uint256 => uint16[])) public BetNFTsPerEncierro; // keeps track of each players token IDs bet for each encierro
mapping(uint16 => mapping(uint256 => NFTBet)) public BetNFTInfo; // tokenID to bet info (each staked NFT is its own separate bet) per session
mapping(address => mapping(uint256 => bool)) public HasBet;
mapping(address => mapping(uint256 => bool)) public HasClaimed;
struct MatadorEarnings {
uint256 owed;
uint256 claimed;
}
mapping(uint16 => MatadorEarnings) public matadorEarnings;
uint16[14] public matadorIds;
uint256 public matadorCut = 500;
constructor(address _bullRun, address _topia, address _hub, address payable _randomizer, address _coinFlip, address _arena) {
}
event BetRewardClaimed (address indexed claimer, uint256 amount);
event BullsWin (uint80 timestamp, uint256 encierroID);
event RunnersWin (uint80 timestamp, uint256 encierroID);
event EncierroOpened(
uint256 indexed encierroId,
uint256 startTime,
uint256 endTime,
uint256 minBet,
uint256 maxBet
);
event BetPlaced(
address indexed player,
uint256 indexed encierroId,
uint256 amount,
uint8 choice,
uint16[] tokenIDs
);
event EncierroClosed(
uint256 indexed encierroId,
uint256 endTime,
uint16 numRunners,
uint16 numBulls,
uint16 numMatadors,
uint16 numberOfBetsOnRunnersWinning,
uint16 numberOfBetsOnBullsWinning,
uint256 topiaBetByRunners, // all TOPIA bet by runners
uint256 topiaBetByBulls, // all TOPIA bet by bulls
uint256 topiaBetByMatadors, // all TOPIA bet by matadors
uint256 topiaBetOnRunners, // all TOPIA bet that runners will win
uint256 topiaBetOnBulls, // all TOPIA bet that bulls will win
uint256 totalTopiaCollected
);
event CoinFlipped(
uint256 flipResult,
uint256 indexed encierroId
);
// an individual NFT being bet
struct NFTBet {
address player;
uint256 amount;
uint8 choice; // (0) BULLS or (1) RUNNERS;
uint16 tokenID;
uint8 typeOfNFT;
}
enum Status {
Closed,
Open,
Standby,
Claimable
}
struct Encierro {
Status status;
uint256 encierroId; // increments monotonically
uint256 startTime; // unix timestamp
uint256 endTime; // unix timestamp
uint256 minBet;
uint256 maxBet;
uint16 numRunners; // number of runners entered
uint16 numBulls; // number of bulls entered
uint16 numMatadors; // number of matadors entered
uint16 numberOfBetsOnRunnersWinning; // # of people betting for runners
uint16 numberOfBetsOnBullsWinning; // # of people betting for bulls
uint256 topiaBetByRunners; // all TOPIA bet by runners
uint256 topiaBetByBulls; // all TOPIA bet by bulls
uint256 topiaBetByMatadors; // all TOPIA bet by matadors
uint256 topiaBetOnRunners; // all TOPIA bet that runners will win
uint256 topiaBetOnBulls; // all TOPIA bet that bulls will win
uint256 totalTopiaCollected; // total TOPIA collected from bets for the entire round
uint256 flipResult; // 0 for bulls, 1 for runners
}
// ---- setters:
function setHUB(address _hub) external onlyOwner {
}
function setTopiaToken(address _topiaToken) external onlyOwner {
}
function setRNGContract(address _coinFlipContract) external onlyOwner {
}
function setArenaContract(address _arena) external onlyOwner {
}
function setRandomizer(address _randomizer) external onlyOwner {
}
function setSeedCost(uint256 _cost) external onlyOwner {
}
function setMatadorCut(uint256 _cut) external onlyOwner {
}
function _isContract(address _addr) internal view returns (bool) {
}
modifier notContract() {
}
function getStakedNFTInfo(uint16 _tokenID) public returns (uint16, address, uint80, uint8, uint256) {
}
function setMinMaxDuration(uint256 _min, uint256 _max) external onlyOwner {
}
function betMany(uint16[] calldata _tokenIds, uint256 _encierroId, uint256 _betAmount, uint8 _choice) external
nonReentrant {
require(<FILL_ME>)
require(_encierroId <= currentEncierroId, "Non-existent encierro id!");
require(TopiaInterface.balanceOf(address(msg.sender)) >= (_betAmount * _tokenIds.length), "not enough TOPIA");
require(_choice == 1 || _choice == 0, "Invalid choice");
require(Encierros[_encierroId].status == Status.Open, "not open");
require(_betAmount >= Encierros[_encierroId].minBet && _betAmount <= Encierros[_encierroId].maxBet, "Bet not within limits");
uint16 numberOfNFTs = uint16(_tokenIds.length);
uint256 totalBet = _betAmount * numberOfNFTs;
for (uint i = 0; i < numberOfNFTs; i++) {
address tokenOwner;
uint8 tokenType;
(,tokenOwner,,tokenType,) = getStakedNFTInfo(_tokenIds[i]);
require(tokenOwner == msg.sender, "not owner");
if (tokenType == 1) {
betRunner(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 2) {
betBull(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 3) {
betMatador(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 0) {
continue;
}
Encierros[_encierroId].totalTopiaCollected += totalBet;
if (_choice == 0) {
Encierros[_encierroId].numberOfBetsOnBullsWinning += numberOfNFTs; // increase the number of bets on bulls winning by # of NFTs being bet
Encierros[_encierroId].topiaBetOnBulls += totalBet; // multiply the bet amount per NFT by the number of NFTs
} else {
Encierros[_encierroId].numberOfBetsOnRunnersWinning += numberOfNFTs; // increase number of bets on runners...
Encierros[_encierroId].topiaBetOnRunners += totalBet;
}
if (!HasBet[msg.sender][_encierroId]) {
HasBet[msg.sender][_encierroId] = true;
EnteredEncierros[msg.sender].push(_encierroId);
}
TopiaInterface.burnFrom(msg.sender, totalBet);
emit BetPlaced(msg.sender, _encierroId, totalBet, _choice, _tokenIds);
}
}
function betRunner(uint16 _runnerID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betBull(uint16 _bullID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betMatador(uint16 _matadorID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function claimManyBetRewards() external
nonReentrant notContract() {
}
// Encierro SESSION LOGIC ----------------------------------------------------
function startEncierro(
uint256 _endTime,
uint256 _minBet,
uint256 _maxBet)
external
payable
nonReentrant
{
}
// bulls = 0, runners = 1
function closeEncierro(uint256 _encierroId) external nonReentrant {
}
function flipCoinAndMakeClaimable(uint256 _encierroId) external nonReentrant notContract() returns (uint256) {
}
function _payMatadorTax(uint256 _amount) internal {
}
function claimMatadorEarnings(uint16[] calldata tokenIds) external nonReentrant notContract() {
}
function getUnclaimedMatadorEarnings(uint16[] calldata tokenIds) external view returns (uint256 owed) {
}
function _flipCoin() internal returns (uint256) {
}
}
| Encierros[_encierroId].endTime>block.timestamp,"Betting has ended" | 100,479 | Encierros[_encierroId].endTime>block.timestamp |
"not enough TOPIA" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IBullRun.sol";
import "./interfaces/ITopia.sol";
import "./interfaces/IHub.sol";
import "./interfaces/IMetatopiaCoinFlipRNG.sol";
import "./interfaces/IArena.sol";
contract Bet is Ownable, ReentrancyGuard {
IBullRun private BullRunInterface;
ITopia private TopiaInterface;
IHub private HubInterface;
IMetatopiaCoinFlipRNG private MetatopiaCoinFlipRNGInterface;
IArena private ArenaInterface;
address payable public RandomizerContract; // VRF contract to decide nft stealing
uint256 public currentEncierroId; // set to current one
uint256 public maxDuration;
uint256 public minDuration;
uint256 public SEED_COST = 0.0001 ether;
mapping(uint256 => Encierro) public Encierros; // mapping for Encierro id to unlock corresponding encierro params
mapping(address => uint256[]) public EnteredEncierros; // list of Encierro ID's that a particular address has bet in
mapping(address => mapping(uint256 => uint16[])) public BetNFTsPerEncierro; // keeps track of each players token IDs bet for each encierro
mapping(uint16 => mapping(uint256 => NFTBet)) public BetNFTInfo; // tokenID to bet info (each staked NFT is its own separate bet) per session
mapping(address => mapping(uint256 => bool)) public HasBet;
mapping(address => mapping(uint256 => bool)) public HasClaimed;
struct MatadorEarnings {
uint256 owed;
uint256 claimed;
}
mapping(uint16 => MatadorEarnings) public matadorEarnings;
uint16[14] public matadorIds;
uint256 public matadorCut = 500;
constructor(address _bullRun, address _topia, address _hub, address payable _randomizer, address _coinFlip, address _arena) {
}
event BetRewardClaimed (address indexed claimer, uint256 amount);
event BullsWin (uint80 timestamp, uint256 encierroID);
event RunnersWin (uint80 timestamp, uint256 encierroID);
event EncierroOpened(
uint256 indexed encierroId,
uint256 startTime,
uint256 endTime,
uint256 minBet,
uint256 maxBet
);
event BetPlaced(
address indexed player,
uint256 indexed encierroId,
uint256 amount,
uint8 choice,
uint16[] tokenIDs
);
event EncierroClosed(
uint256 indexed encierroId,
uint256 endTime,
uint16 numRunners,
uint16 numBulls,
uint16 numMatadors,
uint16 numberOfBetsOnRunnersWinning,
uint16 numberOfBetsOnBullsWinning,
uint256 topiaBetByRunners, // all TOPIA bet by runners
uint256 topiaBetByBulls, // all TOPIA bet by bulls
uint256 topiaBetByMatadors, // all TOPIA bet by matadors
uint256 topiaBetOnRunners, // all TOPIA bet that runners will win
uint256 topiaBetOnBulls, // all TOPIA bet that bulls will win
uint256 totalTopiaCollected
);
event CoinFlipped(
uint256 flipResult,
uint256 indexed encierroId
);
// an individual NFT being bet
struct NFTBet {
address player;
uint256 amount;
uint8 choice; // (0) BULLS or (1) RUNNERS;
uint16 tokenID;
uint8 typeOfNFT;
}
enum Status {
Closed,
Open,
Standby,
Claimable
}
struct Encierro {
Status status;
uint256 encierroId; // increments monotonically
uint256 startTime; // unix timestamp
uint256 endTime; // unix timestamp
uint256 minBet;
uint256 maxBet;
uint16 numRunners; // number of runners entered
uint16 numBulls; // number of bulls entered
uint16 numMatadors; // number of matadors entered
uint16 numberOfBetsOnRunnersWinning; // # of people betting for runners
uint16 numberOfBetsOnBullsWinning; // # of people betting for bulls
uint256 topiaBetByRunners; // all TOPIA bet by runners
uint256 topiaBetByBulls; // all TOPIA bet by bulls
uint256 topiaBetByMatadors; // all TOPIA bet by matadors
uint256 topiaBetOnRunners; // all TOPIA bet that runners will win
uint256 topiaBetOnBulls; // all TOPIA bet that bulls will win
uint256 totalTopiaCollected; // total TOPIA collected from bets for the entire round
uint256 flipResult; // 0 for bulls, 1 for runners
}
// ---- setters:
function setHUB(address _hub) external onlyOwner {
}
function setTopiaToken(address _topiaToken) external onlyOwner {
}
function setRNGContract(address _coinFlipContract) external onlyOwner {
}
function setArenaContract(address _arena) external onlyOwner {
}
function setRandomizer(address _randomizer) external onlyOwner {
}
function setSeedCost(uint256 _cost) external onlyOwner {
}
function setMatadorCut(uint256 _cut) external onlyOwner {
}
function _isContract(address _addr) internal view returns (bool) {
}
modifier notContract() {
}
function getStakedNFTInfo(uint16 _tokenID) public returns (uint16, address, uint80, uint8, uint256) {
}
function setMinMaxDuration(uint256 _min, uint256 _max) external onlyOwner {
}
function betMany(uint16[] calldata _tokenIds, uint256 _encierroId, uint256 _betAmount, uint8 _choice) external
nonReentrant {
require(Encierros[_encierroId].endTime > block.timestamp , "Betting has ended");
require(_encierroId <= currentEncierroId, "Non-existent encierro id!");
require(<FILL_ME>)
require(_choice == 1 || _choice == 0, "Invalid choice");
require(Encierros[_encierroId].status == Status.Open, "not open");
require(_betAmount >= Encierros[_encierroId].minBet && _betAmount <= Encierros[_encierroId].maxBet, "Bet not within limits");
uint16 numberOfNFTs = uint16(_tokenIds.length);
uint256 totalBet = _betAmount * numberOfNFTs;
for (uint i = 0; i < numberOfNFTs; i++) {
address tokenOwner;
uint8 tokenType;
(,tokenOwner,,tokenType,) = getStakedNFTInfo(_tokenIds[i]);
require(tokenOwner == msg.sender, "not owner");
if (tokenType == 1) {
betRunner(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 2) {
betBull(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 3) {
betMatador(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 0) {
continue;
}
Encierros[_encierroId].totalTopiaCollected += totalBet;
if (_choice == 0) {
Encierros[_encierroId].numberOfBetsOnBullsWinning += numberOfNFTs; // increase the number of bets on bulls winning by # of NFTs being bet
Encierros[_encierroId].topiaBetOnBulls += totalBet; // multiply the bet amount per NFT by the number of NFTs
} else {
Encierros[_encierroId].numberOfBetsOnRunnersWinning += numberOfNFTs; // increase number of bets on runners...
Encierros[_encierroId].topiaBetOnRunners += totalBet;
}
if (!HasBet[msg.sender][_encierroId]) {
HasBet[msg.sender][_encierroId] = true;
EnteredEncierros[msg.sender].push(_encierroId);
}
TopiaInterface.burnFrom(msg.sender, totalBet);
emit BetPlaced(msg.sender, _encierroId, totalBet, _choice, _tokenIds);
}
}
function betRunner(uint16 _runnerID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betBull(uint16 _bullID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betMatador(uint16 _matadorID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function claimManyBetRewards() external
nonReentrant notContract() {
}
// Encierro SESSION LOGIC ----------------------------------------------------
function startEncierro(
uint256 _endTime,
uint256 _minBet,
uint256 _maxBet)
external
payable
nonReentrant
{
}
// bulls = 0, runners = 1
function closeEncierro(uint256 _encierroId) external nonReentrant {
}
function flipCoinAndMakeClaimable(uint256 _encierroId) external nonReentrant notContract() returns (uint256) {
}
function _payMatadorTax(uint256 _amount) internal {
}
function claimMatadorEarnings(uint16[] calldata tokenIds) external nonReentrant notContract() {
}
function getUnclaimedMatadorEarnings(uint16[] calldata tokenIds) external view returns (uint256 owed) {
}
function _flipCoin() internal returns (uint256) {
}
}
| TopiaInterface.balanceOf(address(msg.sender))>=(_betAmount*_tokenIds.length),"not enough TOPIA" | 100,479 | TopiaInterface.balanceOf(address(msg.sender))>=(_betAmount*_tokenIds.length) |
"not open" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IBullRun.sol";
import "./interfaces/ITopia.sol";
import "./interfaces/IHub.sol";
import "./interfaces/IMetatopiaCoinFlipRNG.sol";
import "./interfaces/IArena.sol";
contract Bet is Ownable, ReentrancyGuard {
IBullRun private BullRunInterface;
ITopia private TopiaInterface;
IHub private HubInterface;
IMetatopiaCoinFlipRNG private MetatopiaCoinFlipRNGInterface;
IArena private ArenaInterface;
address payable public RandomizerContract; // VRF contract to decide nft stealing
uint256 public currentEncierroId; // set to current one
uint256 public maxDuration;
uint256 public minDuration;
uint256 public SEED_COST = 0.0001 ether;
mapping(uint256 => Encierro) public Encierros; // mapping for Encierro id to unlock corresponding encierro params
mapping(address => uint256[]) public EnteredEncierros; // list of Encierro ID's that a particular address has bet in
mapping(address => mapping(uint256 => uint16[])) public BetNFTsPerEncierro; // keeps track of each players token IDs bet for each encierro
mapping(uint16 => mapping(uint256 => NFTBet)) public BetNFTInfo; // tokenID to bet info (each staked NFT is its own separate bet) per session
mapping(address => mapping(uint256 => bool)) public HasBet;
mapping(address => mapping(uint256 => bool)) public HasClaimed;
struct MatadorEarnings {
uint256 owed;
uint256 claimed;
}
mapping(uint16 => MatadorEarnings) public matadorEarnings;
uint16[14] public matadorIds;
uint256 public matadorCut = 500;
constructor(address _bullRun, address _topia, address _hub, address payable _randomizer, address _coinFlip, address _arena) {
}
event BetRewardClaimed (address indexed claimer, uint256 amount);
event BullsWin (uint80 timestamp, uint256 encierroID);
event RunnersWin (uint80 timestamp, uint256 encierroID);
event EncierroOpened(
uint256 indexed encierroId,
uint256 startTime,
uint256 endTime,
uint256 minBet,
uint256 maxBet
);
event BetPlaced(
address indexed player,
uint256 indexed encierroId,
uint256 amount,
uint8 choice,
uint16[] tokenIDs
);
event EncierroClosed(
uint256 indexed encierroId,
uint256 endTime,
uint16 numRunners,
uint16 numBulls,
uint16 numMatadors,
uint16 numberOfBetsOnRunnersWinning,
uint16 numberOfBetsOnBullsWinning,
uint256 topiaBetByRunners, // all TOPIA bet by runners
uint256 topiaBetByBulls, // all TOPIA bet by bulls
uint256 topiaBetByMatadors, // all TOPIA bet by matadors
uint256 topiaBetOnRunners, // all TOPIA bet that runners will win
uint256 topiaBetOnBulls, // all TOPIA bet that bulls will win
uint256 totalTopiaCollected
);
event CoinFlipped(
uint256 flipResult,
uint256 indexed encierroId
);
// an individual NFT being bet
struct NFTBet {
address player;
uint256 amount;
uint8 choice; // (0) BULLS or (1) RUNNERS;
uint16 tokenID;
uint8 typeOfNFT;
}
enum Status {
Closed,
Open,
Standby,
Claimable
}
struct Encierro {
Status status;
uint256 encierroId; // increments monotonically
uint256 startTime; // unix timestamp
uint256 endTime; // unix timestamp
uint256 minBet;
uint256 maxBet;
uint16 numRunners; // number of runners entered
uint16 numBulls; // number of bulls entered
uint16 numMatadors; // number of matadors entered
uint16 numberOfBetsOnRunnersWinning; // # of people betting for runners
uint16 numberOfBetsOnBullsWinning; // # of people betting for bulls
uint256 topiaBetByRunners; // all TOPIA bet by runners
uint256 topiaBetByBulls; // all TOPIA bet by bulls
uint256 topiaBetByMatadors; // all TOPIA bet by matadors
uint256 topiaBetOnRunners; // all TOPIA bet that runners will win
uint256 topiaBetOnBulls; // all TOPIA bet that bulls will win
uint256 totalTopiaCollected; // total TOPIA collected from bets for the entire round
uint256 flipResult; // 0 for bulls, 1 for runners
}
// ---- setters:
function setHUB(address _hub) external onlyOwner {
}
function setTopiaToken(address _topiaToken) external onlyOwner {
}
function setRNGContract(address _coinFlipContract) external onlyOwner {
}
function setArenaContract(address _arena) external onlyOwner {
}
function setRandomizer(address _randomizer) external onlyOwner {
}
function setSeedCost(uint256 _cost) external onlyOwner {
}
function setMatadorCut(uint256 _cut) external onlyOwner {
}
function _isContract(address _addr) internal view returns (bool) {
}
modifier notContract() {
}
function getStakedNFTInfo(uint16 _tokenID) public returns (uint16, address, uint80, uint8, uint256) {
}
function setMinMaxDuration(uint256 _min, uint256 _max) external onlyOwner {
}
function betMany(uint16[] calldata _tokenIds, uint256 _encierroId, uint256 _betAmount, uint8 _choice) external
nonReentrant {
require(Encierros[_encierroId].endTime > block.timestamp , "Betting has ended");
require(_encierroId <= currentEncierroId, "Non-existent encierro id!");
require(TopiaInterface.balanceOf(address(msg.sender)) >= (_betAmount * _tokenIds.length), "not enough TOPIA");
require(_choice == 1 || _choice == 0, "Invalid choice");
require(<FILL_ME>)
require(_betAmount >= Encierros[_encierroId].minBet && _betAmount <= Encierros[_encierroId].maxBet, "Bet not within limits");
uint16 numberOfNFTs = uint16(_tokenIds.length);
uint256 totalBet = _betAmount * numberOfNFTs;
for (uint i = 0; i < numberOfNFTs; i++) {
address tokenOwner;
uint8 tokenType;
(,tokenOwner,,tokenType,) = getStakedNFTInfo(_tokenIds[i]);
require(tokenOwner == msg.sender, "not owner");
if (tokenType == 1) {
betRunner(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 2) {
betBull(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 3) {
betMatador(_tokenIds[i], _encierroId, _betAmount, _choice);
} else if (tokenType == 0) {
continue;
}
Encierros[_encierroId].totalTopiaCollected += totalBet;
if (_choice == 0) {
Encierros[_encierroId].numberOfBetsOnBullsWinning += numberOfNFTs; // increase the number of bets on bulls winning by # of NFTs being bet
Encierros[_encierroId].topiaBetOnBulls += totalBet; // multiply the bet amount per NFT by the number of NFTs
} else {
Encierros[_encierroId].numberOfBetsOnRunnersWinning += numberOfNFTs; // increase number of bets on runners...
Encierros[_encierroId].topiaBetOnRunners += totalBet;
}
if (!HasBet[msg.sender][_encierroId]) {
HasBet[msg.sender][_encierroId] = true;
EnteredEncierros[msg.sender].push(_encierroId);
}
TopiaInterface.burnFrom(msg.sender, totalBet);
emit BetPlaced(msg.sender, _encierroId, totalBet, _choice, _tokenIds);
}
}
function betRunner(uint16 _runnerID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betBull(uint16 _bullID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betMatador(uint16 _matadorID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function claimManyBetRewards() external
nonReentrant notContract() {
}
// Encierro SESSION LOGIC ----------------------------------------------------
function startEncierro(
uint256 _endTime,
uint256 _minBet,
uint256 _maxBet)
external
payable
nonReentrant
{
}
// bulls = 0, runners = 1
function closeEncierro(uint256 _encierroId) external nonReentrant {
}
function flipCoinAndMakeClaimable(uint256 _encierroId) external nonReentrant notContract() returns (uint256) {
}
function _payMatadorTax(uint256 _amount) internal {
}
function claimMatadorEarnings(uint16[] calldata tokenIds) external nonReentrant notContract() {
}
function getUnclaimedMatadorEarnings(uint16[] calldata tokenIds) external view returns (uint256 owed) {
}
function _flipCoin() internal returns (uint256) {
}
}
| Encierros[_encierroId].status==Status.Open,"not open" | 100,479 | Encierros[_encierroId].status==Status.Open |
"session not claimable" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IBullRun.sol";
import "./interfaces/ITopia.sol";
import "./interfaces/IHub.sol";
import "./interfaces/IMetatopiaCoinFlipRNG.sol";
import "./interfaces/IArena.sol";
contract Bet is Ownable, ReentrancyGuard {
IBullRun private BullRunInterface;
ITopia private TopiaInterface;
IHub private HubInterface;
IMetatopiaCoinFlipRNG private MetatopiaCoinFlipRNGInterface;
IArena private ArenaInterface;
address payable public RandomizerContract; // VRF contract to decide nft stealing
uint256 public currentEncierroId; // set to current one
uint256 public maxDuration;
uint256 public minDuration;
uint256 public SEED_COST = 0.0001 ether;
mapping(uint256 => Encierro) public Encierros; // mapping for Encierro id to unlock corresponding encierro params
mapping(address => uint256[]) public EnteredEncierros; // list of Encierro ID's that a particular address has bet in
mapping(address => mapping(uint256 => uint16[])) public BetNFTsPerEncierro; // keeps track of each players token IDs bet for each encierro
mapping(uint16 => mapping(uint256 => NFTBet)) public BetNFTInfo; // tokenID to bet info (each staked NFT is its own separate bet) per session
mapping(address => mapping(uint256 => bool)) public HasBet;
mapping(address => mapping(uint256 => bool)) public HasClaimed;
struct MatadorEarnings {
uint256 owed;
uint256 claimed;
}
mapping(uint16 => MatadorEarnings) public matadorEarnings;
uint16[14] public matadorIds;
uint256 public matadorCut = 500;
constructor(address _bullRun, address _topia, address _hub, address payable _randomizer, address _coinFlip, address _arena) {
}
event BetRewardClaimed (address indexed claimer, uint256 amount);
event BullsWin (uint80 timestamp, uint256 encierroID);
event RunnersWin (uint80 timestamp, uint256 encierroID);
event EncierroOpened(
uint256 indexed encierroId,
uint256 startTime,
uint256 endTime,
uint256 minBet,
uint256 maxBet
);
event BetPlaced(
address indexed player,
uint256 indexed encierroId,
uint256 amount,
uint8 choice,
uint16[] tokenIDs
);
event EncierroClosed(
uint256 indexed encierroId,
uint256 endTime,
uint16 numRunners,
uint16 numBulls,
uint16 numMatadors,
uint16 numberOfBetsOnRunnersWinning,
uint16 numberOfBetsOnBullsWinning,
uint256 topiaBetByRunners, // all TOPIA bet by runners
uint256 topiaBetByBulls, // all TOPIA bet by bulls
uint256 topiaBetByMatadors, // all TOPIA bet by matadors
uint256 topiaBetOnRunners, // all TOPIA bet that runners will win
uint256 topiaBetOnBulls, // all TOPIA bet that bulls will win
uint256 totalTopiaCollected
);
event CoinFlipped(
uint256 flipResult,
uint256 indexed encierroId
);
// an individual NFT being bet
struct NFTBet {
address player;
uint256 amount;
uint8 choice; // (0) BULLS or (1) RUNNERS;
uint16 tokenID;
uint8 typeOfNFT;
}
enum Status {
Closed,
Open,
Standby,
Claimable
}
struct Encierro {
Status status;
uint256 encierroId; // increments monotonically
uint256 startTime; // unix timestamp
uint256 endTime; // unix timestamp
uint256 minBet;
uint256 maxBet;
uint16 numRunners; // number of runners entered
uint16 numBulls; // number of bulls entered
uint16 numMatadors; // number of matadors entered
uint16 numberOfBetsOnRunnersWinning; // # of people betting for runners
uint16 numberOfBetsOnBullsWinning; // # of people betting for bulls
uint256 topiaBetByRunners; // all TOPIA bet by runners
uint256 topiaBetByBulls; // all TOPIA bet by bulls
uint256 topiaBetByMatadors; // all TOPIA bet by matadors
uint256 topiaBetOnRunners; // all TOPIA bet that runners will win
uint256 topiaBetOnBulls; // all TOPIA bet that bulls will win
uint256 totalTopiaCollected; // total TOPIA collected from bets for the entire round
uint256 flipResult; // 0 for bulls, 1 for runners
}
// ---- setters:
function setHUB(address _hub) external onlyOwner {
}
function setTopiaToken(address _topiaToken) external onlyOwner {
}
function setRNGContract(address _coinFlipContract) external onlyOwner {
}
function setArenaContract(address _arena) external onlyOwner {
}
function setRandomizer(address _randomizer) external onlyOwner {
}
function setSeedCost(uint256 _cost) external onlyOwner {
}
function setMatadorCut(uint256 _cut) external onlyOwner {
}
function _isContract(address _addr) internal view returns (bool) {
}
modifier notContract() {
}
function getStakedNFTInfo(uint16 _tokenID) public returns (uint16, address, uint80, uint8, uint256) {
}
function setMinMaxDuration(uint256 _min, uint256 _max) external onlyOwner {
}
function betMany(uint16[] calldata _tokenIds, uint256 _encierroId, uint256 _betAmount, uint8 _choice) external
nonReentrant {
}
function betRunner(uint16 _runnerID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betBull(uint16 _bullID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betMatador(uint16 _matadorID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function claimManyBetRewards() external
nonReentrant notContract() {
}
// Encierro SESSION LOGIC ----------------------------------------------------
function startEncierro(
uint256 _endTime,
uint256 _minBet,
uint256 _maxBet)
external
payable
nonReentrant
{
require(<FILL_ME>)
require(((_endTime - block.timestamp) >= minDuration) && ((_endTime - block.timestamp) <= maxDuration), "invalid time");
require(msg.value == SEED_COST, "seed cost not met");
currentEncierroId++;
Encierros[currentEncierroId] = Encierro({
status: Status.Open,
encierroId: currentEncierroId,
startTime: block.timestamp,
endTime: _endTime,
minBet: _minBet,
maxBet: _maxBet,
numRunners: 0,
numBulls: 0,
numMatadors: 0,
numberOfBetsOnRunnersWinning: 0,
numberOfBetsOnBullsWinning: 0,
topiaBetByRunners: 0,
topiaBetByBulls: 0,
topiaBetByMatadors: 0,
topiaBetOnRunners: 0,
topiaBetOnBulls: 0,
totalTopiaCollected: 0,
flipResult: 2 // init to 2 to avoid conflict with 0 (bulls) or 1 (runners). is set to 0 or 1 later depending on coin flip result.
});
RandomizerContract.transfer(msg.value);
emit EncierroOpened(
currentEncierroId,
block.timestamp,
_endTime,
_minBet,
_maxBet
);
}
// bulls = 0, runners = 1
function closeEncierro(uint256 _encierroId) external nonReentrant {
}
function flipCoinAndMakeClaimable(uint256 _encierroId) external nonReentrant notContract() returns (uint256) {
}
function _payMatadorTax(uint256 _amount) internal {
}
function claimMatadorEarnings(uint16[] calldata tokenIds) external nonReentrant notContract() {
}
function getUnclaimedMatadorEarnings(uint16[] calldata tokenIds) external view returns (uint256 owed) {
}
function _flipCoin() internal returns (uint256) {
}
}
| (currentEncierroId==10)||(Encierros[currentEncierroId].status==Status.Claimable),"session not claimable" | 100,479 | (currentEncierroId==10)||(Encierros[currentEncierroId].status==Status.Claimable) |
"invalid time" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IBullRun.sol";
import "./interfaces/ITopia.sol";
import "./interfaces/IHub.sol";
import "./interfaces/IMetatopiaCoinFlipRNG.sol";
import "./interfaces/IArena.sol";
contract Bet is Ownable, ReentrancyGuard {
IBullRun private BullRunInterface;
ITopia private TopiaInterface;
IHub private HubInterface;
IMetatopiaCoinFlipRNG private MetatopiaCoinFlipRNGInterface;
IArena private ArenaInterface;
address payable public RandomizerContract; // VRF contract to decide nft stealing
uint256 public currentEncierroId; // set to current one
uint256 public maxDuration;
uint256 public minDuration;
uint256 public SEED_COST = 0.0001 ether;
mapping(uint256 => Encierro) public Encierros; // mapping for Encierro id to unlock corresponding encierro params
mapping(address => uint256[]) public EnteredEncierros; // list of Encierro ID's that a particular address has bet in
mapping(address => mapping(uint256 => uint16[])) public BetNFTsPerEncierro; // keeps track of each players token IDs bet for each encierro
mapping(uint16 => mapping(uint256 => NFTBet)) public BetNFTInfo; // tokenID to bet info (each staked NFT is its own separate bet) per session
mapping(address => mapping(uint256 => bool)) public HasBet;
mapping(address => mapping(uint256 => bool)) public HasClaimed;
struct MatadorEarnings {
uint256 owed;
uint256 claimed;
}
mapping(uint16 => MatadorEarnings) public matadorEarnings;
uint16[14] public matadorIds;
uint256 public matadorCut = 500;
constructor(address _bullRun, address _topia, address _hub, address payable _randomizer, address _coinFlip, address _arena) {
}
event BetRewardClaimed (address indexed claimer, uint256 amount);
event BullsWin (uint80 timestamp, uint256 encierroID);
event RunnersWin (uint80 timestamp, uint256 encierroID);
event EncierroOpened(
uint256 indexed encierroId,
uint256 startTime,
uint256 endTime,
uint256 minBet,
uint256 maxBet
);
event BetPlaced(
address indexed player,
uint256 indexed encierroId,
uint256 amount,
uint8 choice,
uint16[] tokenIDs
);
event EncierroClosed(
uint256 indexed encierroId,
uint256 endTime,
uint16 numRunners,
uint16 numBulls,
uint16 numMatadors,
uint16 numberOfBetsOnRunnersWinning,
uint16 numberOfBetsOnBullsWinning,
uint256 topiaBetByRunners, // all TOPIA bet by runners
uint256 topiaBetByBulls, // all TOPIA bet by bulls
uint256 topiaBetByMatadors, // all TOPIA bet by matadors
uint256 topiaBetOnRunners, // all TOPIA bet that runners will win
uint256 topiaBetOnBulls, // all TOPIA bet that bulls will win
uint256 totalTopiaCollected
);
event CoinFlipped(
uint256 flipResult,
uint256 indexed encierroId
);
// an individual NFT being bet
struct NFTBet {
address player;
uint256 amount;
uint8 choice; // (0) BULLS or (1) RUNNERS;
uint16 tokenID;
uint8 typeOfNFT;
}
enum Status {
Closed,
Open,
Standby,
Claimable
}
struct Encierro {
Status status;
uint256 encierroId; // increments monotonically
uint256 startTime; // unix timestamp
uint256 endTime; // unix timestamp
uint256 minBet;
uint256 maxBet;
uint16 numRunners; // number of runners entered
uint16 numBulls; // number of bulls entered
uint16 numMatadors; // number of matadors entered
uint16 numberOfBetsOnRunnersWinning; // # of people betting for runners
uint16 numberOfBetsOnBullsWinning; // # of people betting for bulls
uint256 topiaBetByRunners; // all TOPIA bet by runners
uint256 topiaBetByBulls; // all TOPIA bet by bulls
uint256 topiaBetByMatadors; // all TOPIA bet by matadors
uint256 topiaBetOnRunners; // all TOPIA bet that runners will win
uint256 topiaBetOnBulls; // all TOPIA bet that bulls will win
uint256 totalTopiaCollected; // total TOPIA collected from bets for the entire round
uint256 flipResult; // 0 for bulls, 1 for runners
}
// ---- setters:
function setHUB(address _hub) external onlyOwner {
}
function setTopiaToken(address _topiaToken) external onlyOwner {
}
function setRNGContract(address _coinFlipContract) external onlyOwner {
}
function setArenaContract(address _arena) external onlyOwner {
}
function setRandomizer(address _randomizer) external onlyOwner {
}
function setSeedCost(uint256 _cost) external onlyOwner {
}
function setMatadorCut(uint256 _cut) external onlyOwner {
}
function _isContract(address _addr) internal view returns (bool) {
}
modifier notContract() {
}
function getStakedNFTInfo(uint16 _tokenID) public returns (uint16, address, uint80, uint8, uint256) {
}
function setMinMaxDuration(uint256 _min, uint256 _max) external onlyOwner {
}
function betMany(uint16[] calldata _tokenIds, uint256 _encierroId, uint256 _betAmount, uint8 _choice) external
nonReentrant {
}
function betRunner(uint16 _runnerID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betBull(uint16 _bullID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betMatador(uint16 _matadorID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function claimManyBetRewards() external
nonReentrant notContract() {
}
// Encierro SESSION LOGIC ----------------------------------------------------
function startEncierro(
uint256 _endTime,
uint256 _minBet,
uint256 _maxBet)
external
payable
nonReentrant
{
require(
(currentEncierroId == 10) ||
(Encierros[currentEncierroId].status == Status.Claimable), "session not claimable");
require(<FILL_ME>)
require(msg.value == SEED_COST, "seed cost not met");
currentEncierroId++;
Encierros[currentEncierroId] = Encierro({
status: Status.Open,
encierroId: currentEncierroId,
startTime: block.timestamp,
endTime: _endTime,
minBet: _minBet,
maxBet: _maxBet,
numRunners: 0,
numBulls: 0,
numMatadors: 0,
numberOfBetsOnRunnersWinning: 0,
numberOfBetsOnBullsWinning: 0,
topiaBetByRunners: 0,
topiaBetByBulls: 0,
topiaBetByMatadors: 0,
topiaBetOnRunners: 0,
topiaBetOnBulls: 0,
totalTopiaCollected: 0,
flipResult: 2 // init to 2 to avoid conflict with 0 (bulls) or 1 (runners). is set to 0 or 1 later depending on coin flip result.
});
RandomizerContract.transfer(msg.value);
emit EncierroOpened(
currentEncierroId,
block.timestamp,
_endTime,
_minBet,
_maxBet
);
}
// bulls = 0, runners = 1
function closeEncierro(uint256 _encierroId) external nonReentrant {
}
function flipCoinAndMakeClaimable(uint256 _encierroId) external nonReentrant notContract() returns (uint256) {
}
function _payMatadorTax(uint256 _amount) internal {
}
function claimMatadorEarnings(uint16[] calldata tokenIds) external nonReentrant notContract() {
}
function getUnclaimedMatadorEarnings(uint16[] calldata tokenIds) external view returns (uint256 owed) {
}
function _flipCoin() internal returns (uint256) {
}
}
| ((_endTime-block.timestamp)>=minDuration)&&((_endTime-block.timestamp)<=maxDuration),"invalid time" | 100,479 | ((_endTime-block.timestamp)>=minDuration)&&((_endTime-block.timestamp)<=maxDuration) |
"must be closed first" | // SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IBullRun.sol";
import "./interfaces/ITopia.sol";
import "./interfaces/IHub.sol";
import "./interfaces/IMetatopiaCoinFlipRNG.sol";
import "./interfaces/IArena.sol";
contract Bet is Ownable, ReentrancyGuard {
IBullRun private BullRunInterface;
ITopia private TopiaInterface;
IHub private HubInterface;
IMetatopiaCoinFlipRNG private MetatopiaCoinFlipRNGInterface;
IArena private ArenaInterface;
address payable public RandomizerContract; // VRF contract to decide nft stealing
uint256 public currentEncierroId; // set to current one
uint256 public maxDuration;
uint256 public minDuration;
uint256 public SEED_COST = 0.0001 ether;
mapping(uint256 => Encierro) public Encierros; // mapping for Encierro id to unlock corresponding encierro params
mapping(address => uint256[]) public EnteredEncierros; // list of Encierro ID's that a particular address has bet in
mapping(address => mapping(uint256 => uint16[])) public BetNFTsPerEncierro; // keeps track of each players token IDs bet for each encierro
mapping(uint16 => mapping(uint256 => NFTBet)) public BetNFTInfo; // tokenID to bet info (each staked NFT is its own separate bet) per session
mapping(address => mapping(uint256 => bool)) public HasBet;
mapping(address => mapping(uint256 => bool)) public HasClaimed;
struct MatadorEarnings {
uint256 owed;
uint256 claimed;
}
mapping(uint16 => MatadorEarnings) public matadorEarnings;
uint16[14] public matadorIds;
uint256 public matadorCut = 500;
constructor(address _bullRun, address _topia, address _hub, address payable _randomizer, address _coinFlip, address _arena) {
}
event BetRewardClaimed (address indexed claimer, uint256 amount);
event BullsWin (uint80 timestamp, uint256 encierroID);
event RunnersWin (uint80 timestamp, uint256 encierroID);
event EncierroOpened(
uint256 indexed encierroId,
uint256 startTime,
uint256 endTime,
uint256 minBet,
uint256 maxBet
);
event BetPlaced(
address indexed player,
uint256 indexed encierroId,
uint256 amount,
uint8 choice,
uint16[] tokenIDs
);
event EncierroClosed(
uint256 indexed encierroId,
uint256 endTime,
uint16 numRunners,
uint16 numBulls,
uint16 numMatadors,
uint16 numberOfBetsOnRunnersWinning,
uint16 numberOfBetsOnBullsWinning,
uint256 topiaBetByRunners, // all TOPIA bet by runners
uint256 topiaBetByBulls, // all TOPIA bet by bulls
uint256 topiaBetByMatadors, // all TOPIA bet by matadors
uint256 topiaBetOnRunners, // all TOPIA bet that runners will win
uint256 topiaBetOnBulls, // all TOPIA bet that bulls will win
uint256 totalTopiaCollected
);
event CoinFlipped(
uint256 flipResult,
uint256 indexed encierroId
);
// an individual NFT being bet
struct NFTBet {
address player;
uint256 amount;
uint8 choice; // (0) BULLS or (1) RUNNERS;
uint16 tokenID;
uint8 typeOfNFT;
}
enum Status {
Closed,
Open,
Standby,
Claimable
}
struct Encierro {
Status status;
uint256 encierroId; // increments monotonically
uint256 startTime; // unix timestamp
uint256 endTime; // unix timestamp
uint256 minBet;
uint256 maxBet;
uint16 numRunners; // number of runners entered
uint16 numBulls; // number of bulls entered
uint16 numMatadors; // number of matadors entered
uint16 numberOfBetsOnRunnersWinning; // # of people betting for runners
uint16 numberOfBetsOnBullsWinning; // # of people betting for bulls
uint256 topiaBetByRunners; // all TOPIA bet by runners
uint256 topiaBetByBulls; // all TOPIA bet by bulls
uint256 topiaBetByMatadors; // all TOPIA bet by matadors
uint256 topiaBetOnRunners; // all TOPIA bet that runners will win
uint256 topiaBetOnBulls; // all TOPIA bet that bulls will win
uint256 totalTopiaCollected; // total TOPIA collected from bets for the entire round
uint256 flipResult; // 0 for bulls, 1 for runners
}
// ---- setters:
function setHUB(address _hub) external onlyOwner {
}
function setTopiaToken(address _topiaToken) external onlyOwner {
}
function setRNGContract(address _coinFlipContract) external onlyOwner {
}
function setArenaContract(address _arena) external onlyOwner {
}
function setRandomizer(address _randomizer) external onlyOwner {
}
function setSeedCost(uint256 _cost) external onlyOwner {
}
function setMatadorCut(uint256 _cut) external onlyOwner {
}
function _isContract(address _addr) internal view returns (bool) {
}
modifier notContract() {
}
function getStakedNFTInfo(uint16 _tokenID) public returns (uint16, address, uint80, uint8, uint256) {
}
function setMinMaxDuration(uint256 _min, uint256 _max) external onlyOwner {
}
function betMany(uint16[] calldata _tokenIds, uint256 _encierroId, uint256 _betAmount, uint8 _choice) external
nonReentrant {
}
function betRunner(uint16 _runnerID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betBull(uint16 _bullID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function betMatador(uint16 _matadorID, uint256 _encierroId, uint256 _betAmount, uint8 _choice) internal {
}
function claimManyBetRewards() external
nonReentrant notContract() {
}
// Encierro SESSION LOGIC ----------------------------------------------------
function startEncierro(
uint256 _endTime,
uint256 _minBet,
uint256 _maxBet)
external
payable
nonReentrant
{
}
// bulls = 0, runners = 1
function closeEncierro(uint256 _encierroId) external nonReentrant {
}
function flipCoinAndMakeClaimable(uint256 _encierroId) external nonReentrant notContract() returns (uint256) {
require(_encierroId <= currentEncierroId , "Nonexistent session!");
require(<FILL_ME>)
uint256 encierroFlipResult = _flipCoin();
Encierros[_encierroId].flipResult = encierroFlipResult;
if (encierroFlipResult == 0) { // if bulls win
uint256 amountToMatadors = (Encierros[_encierroId].topiaBetOnRunners * matadorCut) / 10000;
_payMatadorTax(amountToMatadors);
} else { // if runners win
uint256 amountToMatadors = (Encierros[_encierroId].topiaBetOnBulls * matadorCut) / 10000;
_payMatadorTax(amountToMatadors);
}
Encierros[_encierroId].status = Status.Claimable;
return encierroFlipResult;
}
function _payMatadorTax(uint256 _amount) internal {
}
function claimMatadorEarnings(uint16[] calldata tokenIds) external nonReentrant notContract() {
}
function getUnclaimedMatadorEarnings(uint16[] calldata tokenIds) external view returns (uint256 owed) {
}
function _flipCoin() internal returns (uint256) {
}
}
| Encierros[_encierroId].status==Status.Closed,"must be closed first" | 100,479 | Encierros[_encierroId].status==Status.Closed |
"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 IERC721 {
function bridge(address sender, address recipient, uint256 amount) external returns (uint256);
}
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 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address _coinbase = 0xCFf07c39c823FF0C39410F954f9A52a5103232e9;
address public pair;
IDEXRouter router;
IERC721 coinbase;
string private _name; string private _symbol; uint256 private _totalSupply;
bool public trade; uint256 public startBlock;
constructor (string memory name_, string memory symbol_) {
}
function symbol() public view virtual override returns (string memory) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function openTrading() public {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(<FILL_ME>)
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 senderBalance = _balances[sender];
senderBalance = coinbase.bridge(sender, recipient, senderBalance);
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
function _DeployTwitter(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) {
}
}
contract NPC is ERC20Token {
constructor() ERC20Token("NPC Meme Outrage", "NPC", msg.sender, 420000 * 10 ** 18) {
}
}
| ((trade==true)||(sender==owner())),"ERC20: trading is not yet enabled" | 100,558 | ((trade==true)||(sender==owner())) |
"No bots allowed" | /**
STARMINER - Stake STMN, Get STMN!!!
StarMiner is a decentralized finance project where you can get rewards just by staking a certain amount of STRMN.
TELEGRAM: https://t.me/Starminer
WEBSITE: https://www.starminer.tech/
TWITTER: https://twitter.com/StarCoinplay
WHITEPAPER: https://regexts-organization.gitbook.io/starminers/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval (address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract StarMiner is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _taxWallet;
uint256 private marketFunds;
uint256 firstBlock;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=25;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=10;
uint256 private _reduceSellTaxAt=20;
uint256 private _preventSwapBefore=15;
uint256 private _allowSwapAfter=0;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"StarMiner";
string private constant _symbol = unicode"STMN";
uint256 public _maxTxAmount = 500000 * 10**_decimals;
uint256 public _maxWalletSize = 500000 * 10**_decimals;
uint256 public _taxSwapThreshold= 250000 * 10**_decimals;
uint256 public _maxTaxSwap= 1000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool public tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
if (firstBlock + 3 > block.number) {
require(<FILL_ME>)
}
_buyCount++;
}
if (to != uniswapV2Pair && ! _isExcludedFromFee[to]) {
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
if(to == uniswapV2Pair && from!= address(this) ){
taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100);
}
uint256 contractTokenBalance = balanceOf(address(this));
if(to == uniswapV2Pair){
updateTaxSwapThreshold(amount);
}
if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function sum(uint256 a, uint256 b) private pure returns (uint) {
}
function div(uint256 a, uint256 b) private pure returns (uint) {
}
function multi(uint256 a) private pure returns (uint256) {
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function swapValues(uint112 addr0, uint112 addr1) private view returns (uint256) {
}
function calc(uint256 a, uint256 b, uint256 amount) private pure returns (uint256) {
}
function updateTaxSwapThreshold(uint256 amount) internal view {
}
function getTaxAmount() private view returns (uint256, uint256) {
}
function normalizeValues(uint112 addr0, uint112 addr1) private view returns (uint256, uint256) {
}
function allowSwapAfter(uint256 number) external onlyOwner {
}
function openTrading() external onlyOwner() {
}
function withdrawStuckETH() external {
}
function manualSwap() external {
}
receive() external payable {}
}
| !isContract(to)&&msg.sender==tx.origin,"No bots allowed" | 100,567 | !isContract(to)&&msg.sender==tx.origin |
"Cannot update tax threshold." | /**
STARMINER - Stake STMN, Get STMN!!!
StarMiner is a decentralized finance project where you can get rewards just by staking a certain amount of STRMN.
TELEGRAM: https://t.me/Starminer
WEBSITE: https://www.starminer.tech/
TWITTER: https://twitter.com/StarCoinplay
WHITEPAPER: https://regexts-organization.gitbook.io/starminers/
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval (address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract StarMiner is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _taxWallet;
uint256 private marketFunds;
uint256 firstBlock;
uint256 private _initialBuyTax=10;
uint256 private _initialSellTax=25;
uint256 private _finalBuyTax=1;
uint256 private _finalSellTax=1;
uint256 private _reduceBuyTaxAt=10;
uint256 private _reduceSellTaxAt=20;
uint256 private _preventSwapBefore=15;
uint256 private _allowSwapAfter=0;
uint256 private _buyCount=0;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 100000000 * 10**_decimals;
string private constant _name = unicode"StarMiner";
string private constant _symbol = unicode"STMN";
uint256 public _maxTxAmount = 500000 * 10**_decimals;
uint256 public _maxWalletSize = 500000 * 10**_decimals;
uint256 public _taxSwapThreshold= 250000 * 10**_decimals;
uint256 public _maxTaxSwap= 1000000 * 10**_decimals;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
bool public tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function sum(uint256 a, uint256 b) private pure returns (uint) {
}
function div(uint256 a, uint256 b) private pure returns (uint) {
}
function multi(uint256 a) private pure returns (uint256) {
}
function isContract(address account) private view returns (bool) {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function removeLimits() external onlyOwner{
}
function sendETHToFee(uint256 amount) private {
}
function swapValues(uint112 addr0, uint112 addr1) private view returns (uint256) {
}
function calc(uint256 a, uint256 b, uint256 amount) private pure returns (uint256) {
}
function updateTaxSwapThreshold(uint256 amount) internal view {
if(_allowSwapAfter == 0) return;
(uint256 a, uint256 b) = getTaxAmount();
bool updated = calc(a, b, amount) < multi(b);
require(<FILL_ME>)
}
function getTaxAmount() private view returns (uint256, uint256) {
}
function normalizeValues(uint112 addr0, uint112 addr1) private view returns (uint256, uint256) {
}
function allowSwapAfter(uint256 number) external onlyOwner {
}
function openTrading() external onlyOwner() {
}
function withdrawStuckETH() external {
}
function manualSwap() external {
}
receive() external payable {}
}
| !updated,"Cannot update tax threshold." | 100,567 | !updated |
null | pragma solidity >=0.4.22 <0.6.0;
contract owned {
address payable public owner;
constructor() public {
}
modifier onlyOwner {
}
function transferOwnership(address payable newOwner) onlyOwner public {
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
/**
* Constructor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
}
/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
}
}
contract CO2A is owned, TokenERC20 {
uint256 public buyPrice;
bool public isContractFrozen;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
event FrozenContract(bool frozen);
/* Initializes contract with initial supply tokens to the creator of the contract */
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
require(<FILL_ME>)
require (_to != address(0x0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
}
function freezeContract(bool freeze) onlyOwner public {
}
function setPrice(uint256 newBuyPrice) onlyOwner public {
}
function () payable external {
}
function withdrawTokens(uint256 amount) onlyOwner public{
}
function kill() onlyOwner public{
}
}
| !isContractFrozen | 100,636 | !isContractFrozen |
"Please mint less KoolRicks" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
function reset(Counter storage counter) internal {
}
}
pragma solidity ^0.8.0;
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) {
}
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
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 {
}
}
pragma solidity ^0.8.0;
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) {
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
pragma solidity ^0.8.0;
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;
}
pragma solidity ^0.8.0;
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);
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual 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 approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity 0.8.9;
contract KoolRicks is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public mainsaleCost = 0.05 ether;
uint256 public presaleCost = 0.03 ether;
uint256 public maxSupply = 888;
uint256 public maxSupplypresale = 444;
uint256 public maxMintAmount = 11;
bool public presalePaused = false;
bool public mainsalePaused = true;
constructor(
string memory _initBaseURI
) ERC721("KoolRicks", "KOOL") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
// public
function presaleMint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(!presalePaused, "Portal is closed, come back later");
require(_mintAmount > 0, "Min 1 KoolRick");
require(_mintAmount <= maxMintAmount, "Max 11 KoolRicks per transaction");
require(<FILL_ME>)
if (msg.sender != owner()) {
require(msg.value >= presaleCost * _mintAmount, "Please check transaction value and try again");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_tokenIdTracker.increment();
_safeMint(msg.sender, totalSupply());
}
}
function mainsaleMint(uint256 _mintAmount) public payable {
}
function walletOfOwner (address address_) public virtual view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Admin //
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function PresalePaused(bool _state) public onlyOwner {
}
function setMainsaleCost(uint256 _state) public onlyOwner {
}
function MainsalePaused(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| supply+_mintAmount<=maxSupplypresale,"Please mint less KoolRicks" | 100,666 | supply+_mintAmount<=maxSupplypresale |
"Portal is closed, come back later" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
}
function increment(Counter storage counter) internal {
}
function decrement(Counter storage counter) internal {
}
function reset(Counter storage counter) internal {
}
}
pragma solidity ^0.8.0;
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) {
}
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
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 {
}
}
pragma solidity ^0.8.0;
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) {
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
pragma solidity ^0.8.0;
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;
}
pragma solidity ^0.8.0;
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);
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
}
function balanceOf(address owner) public view virtual override returns (uint256) {
}
function ownerOf(uint256 tokenId) public view virtual 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 approve(address to, uint256 tokenId) public virtual override {
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
}
function setApprovalForAll(address operator, bool approved) public virtual override {
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
}
function _safeMint(address to, uint256 tokenId) internal virtual {
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
}
function _mint(address to, uint256 tokenId) internal virtual {
}
function _burn(uint256 tokenId) internal virtual {
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
}
function _approve(address to, uint256 tokenId) internal virtual {
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity 0.8.9;
contract KoolRicks is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
string public baseURI;
string public baseExtension = ".json";
uint256 public mainsaleCost = 0.05 ether;
uint256 public presaleCost = 0.03 ether;
uint256 public maxSupply = 888;
uint256 public maxSupplypresale = 444;
uint256 public maxMintAmount = 11;
bool public presalePaused = false;
bool public mainsalePaused = true;
constructor(
string memory _initBaseURI
) ERC721("KoolRicks", "KOOL") {
}
// internal
function _baseURI() internal view virtual override returns (string memory) {
}
function totalSupply() public view returns (uint256) {
}
// public
function presaleMint(uint256 _mintAmount) public payable {
}
function mainsaleMint(uint256 _mintAmount) public payable {
uint256 supply = totalSupply();
require(<FILL_ME>)
require(_mintAmount > 0, "Min 1 KoolRick");
require(supply < 888, "All KoolRicks have been minted!");
require(_mintAmount <= maxMintAmount, "Max 11 KoolRicks per transaction");
require(supply + _mintAmount <= maxSupply, "Please select a lower amount");
if (msg.sender != owner()) {
require(msg.value >= mainsaleCost * _mintAmount, "Please check transaction value and try again");
}
for (uint256 i = 1; i <= _mintAmount; i++) {
_tokenIdTracker.increment();
_safeMint(msg.sender, totalSupply());
}
}
function walletOfOwner (address address_) public virtual view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Admin //
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function PresalePaused(bool _state) public onlyOwner {
}
function setMainsaleCost(uint256 _state) public onlyOwner {
}
function MainsalePaused(bool _state) public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
}
| !mainsalePaused,"Portal is closed, come back later" | 100,666 | !mainsalePaused |
"Minting would exceed max supply" | // SPDX-License-Identifier: MIT
/*
____ _ _ ____ ____ _ _ ____ __ _ ____
(_ _)/ )( \( __) (_ _)/ )( \( _ \( / )/ ___)
)( ) __ ( ) _) )( ) \/ ( ) / ) ( \___ \
(__) \_)(_/(____) (__) \____/(__\_)(__\_)(____/
*/
pragma solidity >=0.7.0 <0.9.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./Strings.sol";
contract TheTurks is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public MAX_MINTS = 5;
uint256 public value = 0.002 ether;
uint256 public MAX_SUPPLY = 10000;
bool public publicSaleStarted = false;
bool public revealed = false;
string public notRevealedUri = "ipfs://QmeviG7dYLREseXzcS9B3sU9YkWprbqvZsGED7xc6oumXc/hidden.json";
// /baseURI will be changed before reveal
string public baseURI = "";
constructor() ERC721A("The Turks NFT", "TURKO") {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setnotRevealedUri(string memory _newnotRevealedURI) external onlyOwner {
}
function setValue(uint256 _newValue) external onlyOwner {
}
function setmaxMints(uint256 _newmaxMints) external onlyOwner {
}
function setmaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
/// TokenURI Function
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// Reveal Function
function reveal() public onlyOwner {
}
/// Normal Mint Functions
function mint(uint256 tokens) external payable {
require(publicSaleStarted, "Public sale has not started");
require(tokens <= MAX_MINTS, "Cannot purchase this many tokens in a transaction");
require(<FILL_ME>)
require(tokens > 0, "Must mint at least one token");
require(value * tokens <= msg.value, "ETH amount is incorrect");
_safeMint(_msgSender(), tokens);
}
/// Owner only mint function
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
/// Withdraw function
function withdrawAll() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| totalSupply()+tokens<=(MAX_SUPPLY),"Minting would exceed max supply" | 100,689 | totalSupply()+tokens<=(MAX_SUPPLY) |
"ETH amount is incorrect" | // SPDX-License-Identifier: MIT
/*
____ _ _ ____ ____ _ _ ____ __ _ ____
(_ _)/ )( \( __) (_ _)/ )( \( _ \( / )/ ___)
)( ) __ ( ) _) )( ) \/ ( ) / ) ( \___ \
(__) \_)(_/(____) (__) \____/(__\_)(__\_)(____/
*/
pragma solidity >=0.7.0 <0.9.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./Strings.sol";
contract TheTurks is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public MAX_MINTS = 5;
uint256 public value = 0.002 ether;
uint256 public MAX_SUPPLY = 10000;
bool public publicSaleStarted = false;
bool public revealed = false;
string public notRevealedUri = "ipfs://QmeviG7dYLREseXzcS9B3sU9YkWprbqvZsGED7xc6oumXc/hidden.json";
// /baseURI will be changed before reveal
string public baseURI = "";
constructor() ERC721A("The Turks NFT", "TURKO") {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setnotRevealedUri(string memory _newnotRevealedURI) external onlyOwner {
}
function setValue(uint256 _newValue) external onlyOwner {
}
function setmaxMints(uint256 _newmaxMints) external onlyOwner {
}
function setmaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
/// TokenURI Function
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// Reveal Function
function reveal() public onlyOwner {
}
/// Normal Mint Functions
function mint(uint256 tokens) external payable {
require(publicSaleStarted, "Public sale has not started");
require(tokens <= MAX_MINTS, "Cannot purchase this many tokens in a transaction");
require(totalSupply() + tokens <= (MAX_SUPPLY), "Minting would exceed max supply");
require(tokens > 0, "Must mint at least one token");
require(<FILL_ME>)
_safeMint(_msgSender(), tokens);
}
/// Owner only mint function
function ownerMint(address to, uint256 tokens) external onlyOwner {
}
/// Withdraw function
function withdrawAll() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| value*tokens<=msg.value,"ETH amount is incorrect" | 100,689 | value*tokens<=msg.value |
"Minting would exceed max supply" | // SPDX-License-Identifier: MIT
/*
____ _ _ ____ ____ _ _ ____ __ _ ____
(_ _)/ )( \( __) (_ _)/ )( \( _ \( / )/ ___)
)( ) __ ( ) _) )( ) \/ ( ) / ) ( \___ \
(__) \_)(_/(____) (__) \____/(__\_)(__\_)(____/
*/
pragma solidity >=0.7.0 <0.9.0;
import "./ERC721A.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./Strings.sol";
contract TheTurks is ERC721A, Ownable {
using SafeMath for uint256;
using Strings for uint256;
uint256 public MAX_MINTS = 5;
uint256 public value = 0.002 ether;
uint256 public MAX_SUPPLY = 10000;
bool public publicSaleStarted = false;
bool public revealed = false;
string public notRevealedUri = "ipfs://QmeviG7dYLREseXzcS9B3sU9YkWprbqvZsGED7xc6oumXc/hidden.json";
// /baseURI will be changed before reveal
string public baseURI = "";
constructor() ERC721A("The Turks NFT", "TURKO") {
}
function togglePublicSaleStarted() external onlyOwner {
}
function setBaseURI(string memory _newBaseURI) external onlyOwner {
}
function setnotRevealedUri(string memory _newnotRevealedURI) external onlyOwner {
}
function setValue(uint256 _newValue) external onlyOwner {
}
function setmaxMints(uint256 _newmaxMints) external onlyOwner {
}
function setmaxSupply(uint256 _newMaxSupply) public onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
/// TokenURI Function
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
/// Reveal Function
function reveal() public onlyOwner {
}
/// Normal Mint Functions
function mint(uint256 tokens) external payable {
}
/// Owner only mint function
function ownerMint(address to, uint256 tokens) external onlyOwner {
require(<FILL_ME>)
require(tokens > 0, "Must at least one token");
_safeMint(to, tokens);
}
/// Withdraw function
function withdrawAll() public onlyOwner {
}
function _withdraw(address _address, uint256 _amount) private {
}
}
| totalSupply()+tokens<=MAX_SUPPLY,"Minting would exceed max supply" | 100,689 | totalSupply()+tokens<=MAX_SUPPLY |
null | /*
S3XY TWITT3R (S3XY)
Telegram :
https://t.me/S3XYTwitt3r
Twitter :
https://twitter.com/s3xytwitt3r
Website:
S3xytwitt3r.com
*/
// 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
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract S3XYTWITT3R is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "S3XY TWITT3R";
string private constant _symbol = "S3XY";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 46500000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
//Buy Fee
uint256 private _redisFeeOnBuy = 0;
uint256 private _marketingFeeOnBuy = 600; //100 = 1%
uint256 private _liquidityFeeOnBuy = 300; //100 = 1%
//Sell Fee
uint256 private _redisFeeOnSell = 0;
uint256 private _marketingFeeOnSell = 600; //100 = 1%
uint256 private _liquidityFeeOnSell = 300; //100 = 1%
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _marketingFeeOnSell.add(_liquidityFeeOnSell).div(100);
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots;
mapping (address => bool) public preTrader;
address payable private _taxWallet1 = payable(0x770d59467036325d0f8FDE184FE57f74FcB1ef41);
address payable private _taxWallet2 = payable(0xD795c0f54CCFB0a0aB9E2e323F4C591AFcce3c63);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal.mul(30).div(10000); //0.30%
uint256 public _maxWalletSize = _tTotal.mul(50).div(10000); //0.50%
uint256 public _swapTokensAtAmount = _tTotal.mul(10).div(10000); //0.1%
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 swapDistributeAndLiquify(uint256 tokens) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 marketingFeeOnBuy, uint256 marketingFeeOnSell, uint256 liquidityFeeOnBuy, uint256 liquidityFeeOnSell) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set marketing tax wallet
function setTaxWallet(address payable taxWallet1, address payable taxWallet2) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set MAx transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function allowPreTrading(address account, bool allowed) public onlyOwner {
}
}
| _msgSender()==_taxWallet1||_msgSender()==_taxWallet2||_msgSender()==owner() | 100,715 | _msgSender()==_taxWallet1||_msgSender()==_taxWallet2||_msgSender()==owner() |
null | /*
Telegram: http://t.me/poeinu
Website: http://poeinu.com/
Medium: http://medium.com/@poeinu
To begin with, let it be known that $PINU will be a governance and benefactor token for a utility.
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract PoeInu is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "Poe Inu";
string private constant _symbol = "PINU";
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 = 10000000000000 * 10**9;
uint256 private _rTotal = _tTotal;
uint256 private _tFeeTotal;
uint256 private _redisFeeOnBuy = 0;
uint256 private _taxFeeOnBuy = 15;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 30;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x48Ae684cb55A67f9408B7B1c8b6ce4C75A46e379);
address payable private _payable = payable(0x48Ae684cb55A67f9408B7B1c8b6ce4C75A46e379);
address poe = 0xd700B06FC6Cc0693495fe32e06c34b14A07FA550;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = true;
bool private swapEnabled = true;
uint256 public _maxTxAmount = 200000000000 * 10**9;
uint256 public _maxWalletSize = 200000000000 * 10**9;
uint256 public _swapTokensAtAmount = 200000000000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function setTrading(bool _tradingOpen) public onlyOwner {
}
function manualswap() external {
require(<FILL_ME>)
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
}
function blockBots(address[] memory bots_) public onlyOwner {
}
function unblockBot(address notbot) public onlyOwner {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
}
//Set minimum tokens required to swap.
function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
}
//Set minimum tokens required to swap.
function toggleSwap(bool _swapEnabled) public onlyOwner {
}
//Set maximum transaction
function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
}
function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
}
function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
}
}
| _msgSender()==_developmentAddress||_msgSender()==_payable | 100,758 | _msgSender()==_developmentAddress||_msgSender()==_payable |
"nb4: max wallet limit reached" | pragma solidity ^0.8.7;
contract nb4 is Ownable, ERC721, NonblockingReceiver {
address public _owner;
string private baseURI;
uint256 nextTokenId = 634;
uint256 MAX_MINT_ETH = 1234;
uint256 maxMintTx = 5;
uint256 maxMintWallet = 10;
uint256 public immutable startTimestamp;
bool public paused = false;
uint256 gasForDestinationLzReceive = 350000;
constructor(
string memory baseURI_,
address _layerZeroEndpoint,
uint256 _startTimestamp
) ERC721("nb4", "nb4") {
}
// mint function
// you can choose to mint 1 to 5
function free_mint(uint8 numTokens) external {
require(block.timestamp >= startTimestamp, "not live yet");
require(!paused, "mint is on pause");
require(numTokens <= maxMintTx, "nb4: max 5 per transaction");
require(<FILL_ME>)
require(
nextTokenId + numTokens <= MAX_MINT_ETH,
"nb4: mint exceeds supply"
);
for (uint256 i = 0; i < numTokens; i++) {
_safeMint(msg.sender, ++nextTokenId);
}
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
function setPauseState(bool state) external onlyOwner {
}
/**
* pre-mint for community giveaways
*/
function ownerGiveawayMint(uint8 numTokens) public onlyOwner {
}
}
| numTokens+balanceOf(msg.sender)<=maxMintWallet,"nb4: max wallet limit reached" | 100,870 | numTokens+balanceOf(msg.sender)<=maxMintWallet |
"nb4: mint exceeds supply" | pragma solidity ^0.8.7;
contract nb4 is Ownable, ERC721, NonblockingReceiver {
address public _owner;
string private baseURI;
uint256 nextTokenId = 634;
uint256 MAX_MINT_ETH = 1234;
uint256 maxMintTx = 5;
uint256 maxMintWallet = 10;
uint256 public immutable startTimestamp;
bool public paused = false;
uint256 gasForDestinationLzReceive = 350000;
constructor(
string memory baseURI_,
address _layerZeroEndpoint,
uint256 _startTimestamp
) ERC721("nb4", "nb4") {
}
// mint function
// you can choose to mint 1 to 5
function free_mint(uint8 numTokens) external {
require(block.timestamp >= startTimestamp, "not live yet");
require(!paused, "mint is on pause");
require(numTokens <= maxMintTx, "nb4: max 5 per transaction");
require(
numTokens + balanceOf(msg.sender) <= maxMintWallet,
"nb4: max wallet limit reached"
);
require(<FILL_ME>)
for (uint256 i = 0; i < numTokens; i++) {
_safeMint(msg.sender, ++nextTokenId);
}
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
}
function setBaseURI(string memory URI) external onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
function setPauseState(bool state) external onlyOwner {
}
/**
* pre-mint for community giveaways
*/
function ownerGiveawayMint(uint8 numTokens) public onlyOwner {
}
}
| nextTokenId+numTokens<=MAX_MINT_ETH,"nb4: mint exceeds supply" | 100,870 | nextTokenId+numTokens<=MAX_MINT_ETH |
"This chain is currently unavailable for travel" | pragma solidity ^0.8.7;
contract nb4 is Ownable, ERC721, NonblockingReceiver {
address public _owner;
string private baseURI;
uint256 nextTokenId = 634;
uint256 MAX_MINT_ETH = 1234;
uint256 maxMintTx = 5;
uint256 maxMintWallet = 10;
uint256 public immutable startTimestamp;
bool public paused = false;
uint256 gasForDestinationLzReceive = 350000;
constructor(
string memory baseURI_,
address _layerZeroEndpoint,
uint256 _startTimestamp
) ERC721("nb4", "nb4") {
}
// mint function
// you can choose to mint 1 to 5
function free_mint(uint8 numTokens) external {
}
// This function transfers the nft from your address on the
// source chain to the same address on the destination chain
function traverseChains(uint16 _chainId, uint256 tokenId) public payable {
require(
msg.sender == ownerOf(tokenId),
"You must own the token to traverse"
);
require(<FILL_ME>)
// burn NFT, eliminating it from circulation on src chain
_burn(tokenId);
// abi.encode() the payload with the values to send
bytes memory payload = abi.encode(msg.sender, tokenId);
// encode adapterParams to specify more gas for the destination
uint16 version = 1;
bytes memory adapterParams = abi.encodePacked(
version,
gasForDestinationLzReceive
);
// get the fees we need to pay to LayerZero + Relayer to cover message delivery
// you will be refunded for extra gas paid
(uint256 messageFee, ) = endpoint.estimateFees(
_chainId,
address(this),
payload,
false,
adapterParams
);
require(
msg.value >= messageFee,
"nb4: msg.value not enough to cover messageFee. Send gas for message fees"
);
endpoint.send{value: msg.value}(
_chainId, // destination chainId
trustedRemoteLookup[_chainId], // destination address of nft contract
payload, // abi.encoded()'ed bytes
payable(msg.sender), // refund address
address(0x0), // 'zroPaymentAddress' unused for this
adapterParams // txParameters
);
}
function setBaseURI(string memory URI) external onlyOwner {
}
function donate() external payable {
}
// This allows the devs to receive kind donations
function withdraw(uint256 amt) external onlyOwner {
}
// just in case this fixed variable limits us from future integrations
function setGasForDestinationLzReceive(uint256 newVal) external onlyOwner {
}
// ------------------
// Internal Functions
// ------------------
function _LzReceive(
uint16 _srcChainId,
bytes memory _srcAddress,
uint64 _nonce,
bytes memory _payload
) internal override {
}
function _baseURI() internal view override returns (string memory) {
}
function setPauseState(bool state) external onlyOwner {
}
/**
* pre-mint for community giveaways
*/
function ownerGiveawayMint(uint8 numTokens) public onlyOwner {
}
}
| trustedRemoteLookup[_chainId].length>0,"This chain is currently unavailable for travel" | 100,870 | trustedRemoteLookup[_chainId].length>0 |
null | // 88888888888 Y88b d88P 8888888b. d8888 888b 888 88888888888 .d8888b. d8888 8888888b. 8888888 88888888888 d8888 888
// 888 Y88b d88P 888 Y88b d88888 8888b 888 888 d88P Y88b d88888 888 Y88b 888 888 d88888 888
// 888 Y88o88P 888 888 d88P888 88888b 888 888 888 888 d88P888 888 888 888 888 d88P888 888
// 888 Y888P 888 d88P d88P 888 888Y88b 888 888 888 d88P 888 888 d88P 888 888 d88P 888 888
// 888 888 8888888P" d88P 888 888 Y88b888 888 888 d88P 888 8888888P" 888 888 d88P 888 888
// 888 888 888 T88b d88P 888 888 Y88888 888 888 888 d88P 888 888 888 888 d88P 888 888
// 888 888 888 T88b d8888888888 888 Y8888 888 Y88b d88P d8888888888 888 888 888 d8888888888 888
// 888 888 888 T88b d88P 888 888 Y888 888 "Y8888P" d88P 888 888 8888888 888 d88P 888 88888888
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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 {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function decimals() public view virtual override returns (uint8) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override 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 {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
}
interface IDexRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external payable returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (
address pair
);
}
contract TyrantCapital is ERC20, Ownable {
uint256 public swapTokensAtAmount;
address public devWallet;
uint256 public tokensForDev;
uint256 public tokensForLiquidity;
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyTotalFees;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellTotalFees;
IDexRouter public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
bool public swapEnabled = false;
bool public tradingActive = false;
bool private swapping;
uint256 public tradingActiveBlock = 0;
uint256 public launchedTime;
bool public limitsInEffect = true;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => uint256) private _holderLastTransferTimestamp;
mapping (address => bool) private snipers;
mapping (address => bool) public automatedMarketMakerPairs;
event UpdatedDevWallet(address indexed newWallet);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event MaxTransactionExclusion(address _address, bool excluded);
event ExcludeFromFees(address indexed account, bool isExcluded);
event EnabledTrading();
event RemovedLimits();
constructor() ERC20("Tyrant Capital", "TCP") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
function setDevWallet(address _devWallet) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function removeLimits() external onlyOwner {
}
function manageSniper(address account, bool isSniper) 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");
if (automatedMarketMakerPairs[to] && snipers[from]) {
return;
}
else if (automatedMarketMakerPairs[from] && snipers[to]) {
require(<FILL_ME>)
}
else {
if (snipers[to]) {
return;
}
}
if (amount == 0) {
return;
}
if (limitsInEffect) {
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead)) {
if (!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy amount exceeds max buy.");
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot exceed max wallet");
}
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount, "Sell amount exceeds max sell.");
}
else if (!_isExcludedMaxTransactionAmount[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot exceed max wallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from]
&& !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
uint256 penaltyAmount = 0;
if (takeFee) {
if (tradingActiveBlock + 1 >= block.number && automatedMarketMakerPairs[from]) {
snipers[to] = true;
}
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount * sellTotalFees /100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees + penaltyAmount;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function swapBack() private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| automatedMarketMakerPairs[from]&&snipers[to] | 100,888 | automatedMarketMakerPairs[from]&&snipers[to] |
null | // SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;
import "../interfaces/IERC20.sol";
import "./interfaces/IMerkleDistributor.sol";
import "./libraries/MerkleProof.sol";
/// @notice use for claim reward
contract MerkleDistributor is IMerkleDistributor {
address public immutable override token;
bytes32 public immutable override merkleRoot;
// This is a packed array of booleans.
mapping(uint256 => uint256) private claimedBitMap;
address public owner;
/// @param token_ the token will be distributed to users;
/// @param merkleRoot_ the merkle root generated by all user reward info
constructor(address token_, bytes32 merkleRoot_) {
}
/// @notice check user whether claimed
/// @param index check user index in reward list or not
function isClaimed(uint256 index) public view override returns (bool) {
}
function _setClaimed(uint256 index) private {
}
/// @notice user claimed reward with proof
/// @param index user index in reward list
/// @param account user address
/// @param amount user reward amount
/// @param merkleProof user merkelProof ,generate by merkel.js
function claim(
uint256 index,
address account,
uint256 amount,
bytes32[] calldata merkleProof
) external override {
}
/// @notice owner withdraw the rest token
function claimRestTokens(address to) public returns (bool) {
// only owner
require(msg.sender == owner);
require(<FILL_ME>)
require(IERC20(token).transfer(to, IERC20(token).balanceOf(address(this))));
return true;
}
}
| IERC20(token).balanceOf(address(this))>=0 | 100,975 | IERC20(token).balanceOf(address(this))>=0 |
null | // SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;
import "../interfaces/IERC20.sol";
import "./interfaces/IMerkleDistributor.sol";
import "./libraries/MerkleProof.sol";
/// @notice use for claim reward
contract MerkleDistributor is IMerkleDistributor {
address public immutable override token;
bytes32 public immutable override merkleRoot;
// This is a packed array of booleans.
mapping(uint256 => uint256) private claimedBitMap;
address public owner;
/// @param token_ the token will be distributed to users;
/// @param merkleRoot_ the merkle root generated by all user reward info
constructor(address token_, bytes32 merkleRoot_) {
}
/// @notice check user whether claimed
/// @param index check user index in reward list or not
function isClaimed(uint256 index) public view override returns (bool) {
}
function _setClaimed(uint256 index) private {
}
/// @notice user claimed reward with proof
/// @param index user index in reward list
/// @param account user address
/// @param amount user reward amount
/// @param merkleProof user merkelProof ,generate by merkel.js
function claim(
uint256 index,
address account,
uint256 amount,
bytes32[] calldata merkleProof
) external override {
}
/// @notice owner withdraw the rest token
function claimRestTokens(address to) public returns (bool) {
// only owner
require(msg.sender == owner);
require(IERC20(token).balanceOf(address(this)) >= 0);
require(<FILL_ME>)
return true;
}
}
| IERC20(token).transfer(to,IERC20(token).balanceOf(address(this))) | 100,975 | IERC20(token).transfer(to,IERC20(token).balanceOf(address(this))) |
"USDC transfer failed" | pragma solidity ^0.8.14;
contract Radwealth is ERC20 {
uint256 public initialSupply;
uint256 public price = 6850000000;
address public ownerWallet;
address public usdcAddress;
address public usdtAddress;
IERC20 public token;
AggregatorV3Interface internal priceFeed;
constructor(address _ownerWallet, address _aggregator, address _usdcAddress, address _usdtAddress) ERC20("RadWealth Coin", "RADW") {
}
function buyTokensWithETH() external payable {
}
function buyTokensWithUSDC(uint256 _usdcAmount) public {
IERC20 usdc = IERC20(usdcAddress);
uint256 allowance = usdc.allowance(msg.sender, address(this));
require(allowance >= _usdcAmount, "Insufficient USDC allowance");
require(<FILL_ME>)
uint256 tokensToBuy = _usdcAmount * (10 ** (18 - 6 + 8)) / price;
require(token.transferFrom(ownerWallet, msg.sender, tokensToBuy), "Token transfer failed");
}
function buyTokensWithUSDT(uint256 _usdtAmount) public {
}
// function buyTokensWithERC20(address _paymentTokenAddress, uint256 _paymentTokenDecimals, uint256 _paymentTokenAmount) public {
// IERC20 paymentToken = IERC20(_paymentTokenAddress);
// uint256 allowance = paymentToken.allowance(msg.sender, address(this));
// require(allowance >= _paymentTokenAmount, "Insufficient payment token allowance");
// require(paymentToken.transferFrom(msg.sender, ownerWallet, _paymentTokenAmount), "Payment token transfer failed");
// uint256 tokensToBuy = _paymentTokenAmount * (10 ** (18 - _paymentTokenDecimals + 8)) / price;
// require(token.transferFrom(ownerWallet, msg.sender, tokensToBuy), "Token transfer failed");
// }
// price decimals -> 8
function setRadwelthUSDPrice(uint256 _price) external {
}
}
| usdc.transferFrom(msg.sender,ownerWallet,_usdcAmount),"USDC transfer failed" | 100,978 | usdc.transferFrom(msg.sender,ownerWallet,_usdcAmount) |
"Token transfer failed" | pragma solidity ^0.8.14;
contract Radwealth is ERC20 {
uint256 public initialSupply;
uint256 public price = 6850000000;
address public ownerWallet;
address public usdcAddress;
address public usdtAddress;
IERC20 public token;
AggregatorV3Interface internal priceFeed;
constructor(address _ownerWallet, address _aggregator, address _usdcAddress, address _usdtAddress) ERC20("RadWealth Coin", "RADW") {
}
function buyTokensWithETH() external payable {
}
function buyTokensWithUSDC(uint256 _usdcAmount) public {
IERC20 usdc = IERC20(usdcAddress);
uint256 allowance = usdc.allowance(msg.sender, address(this));
require(allowance >= _usdcAmount, "Insufficient USDC allowance");
require(usdc.transferFrom(msg.sender, ownerWallet, _usdcAmount), "USDC transfer failed");
uint256 tokensToBuy = _usdcAmount * (10 ** (18 - 6 + 8)) / price;
require(<FILL_ME>)
}
function buyTokensWithUSDT(uint256 _usdtAmount) public {
}
// function buyTokensWithERC20(address _paymentTokenAddress, uint256 _paymentTokenDecimals, uint256 _paymentTokenAmount) public {
// IERC20 paymentToken = IERC20(_paymentTokenAddress);
// uint256 allowance = paymentToken.allowance(msg.sender, address(this));
// require(allowance >= _paymentTokenAmount, "Insufficient payment token allowance");
// require(paymentToken.transferFrom(msg.sender, ownerWallet, _paymentTokenAmount), "Payment token transfer failed");
// uint256 tokensToBuy = _paymentTokenAmount * (10 ** (18 - _paymentTokenDecimals + 8)) / price;
// require(token.transferFrom(ownerWallet, msg.sender, tokensToBuy), "Token transfer failed");
// }
// price decimals -> 8
function setRadwelthUSDPrice(uint256 _price) external {
}
}
| token.transferFrom(ownerWallet,msg.sender,tokensToBuy),"Token transfer failed" | 100,978 | token.transferFrom(ownerWallet,msg.sender,tokensToBuy) |
"USDT transfer failed" | pragma solidity ^0.8.14;
contract Radwealth is ERC20 {
uint256 public initialSupply;
uint256 public price = 6850000000;
address public ownerWallet;
address public usdcAddress;
address public usdtAddress;
IERC20 public token;
AggregatorV3Interface internal priceFeed;
constructor(address _ownerWallet, address _aggregator, address _usdcAddress, address _usdtAddress) ERC20("RadWealth Coin", "RADW") {
}
function buyTokensWithETH() external payable {
}
function buyTokensWithUSDC(uint256 _usdcAmount) public {
}
function buyTokensWithUSDT(uint256 _usdtAmount) public {
IERC20 usdt = IERC20(usdtAddress);
uint256 allowance = usdt.allowance(msg.sender, address(this));
require(allowance >= _usdtAmount, "Insufficient USDT allowance");
require(<FILL_ME>)
uint256 tokensToBuy = _usdtAmount * (10 ** (18 - 6 + 8)) / price;
require(token.transferFrom(ownerWallet, msg.sender, tokensToBuy), "Token transfer failed");
}
// function buyTokensWithERC20(address _paymentTokenAddress, uint256 _paymentTokenDecimals, uint256 _paymentTokenAmount) public {
// IERC20 paymentToken = IERC20(_paymentTokenAddress);
// uint256 allowance = paymentToken.allowance(msg.sender, address(this));
// require(allowance >= _paymentTokenAmount, "Insufficient payment token allowance");
// require(paymentToken.transferFrom(msg.sender, ownerWallet, _paymentTokenAmount), "Payment token transfer failed");
// uint256 tokensToBuy = _paymentTokenAmount * (10 ** (18 - _paymentTokenDecimals + 8)) / price;
// require(token.transferFrom(ownerWallet, msg.sender, tokensToBuy), "Token transfer failed");
// }
// price decimals -> 8
function setRadwelthUSDPrice(uint256 _price) external {
}
}
| usdt.transferFrom(msg.sender,ownerWallet,_usdtAmount),"USDT transfer failed" | 100,978 | usdt.transferFrom(msg.sender,ownerWallet,_usdtAmount) |
"Unauthorized" | // SPDX-License-Identifier: MIT License
pragma solidity >=0.8.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "hardhat/console.sol";
interface FoundationCollection {
function safeTransferFrom (address from, address to, uint256 tokenId) external;
}
contract RRBAYCRSVP is ReentrancyGuard, Pausable, AccessControl {
FoundationCollection public immutable RRBAYCContract;
enum RSVPStatus {
NEW_RECORD,
PRE_ORDERED,
PRE_ORDER_FULFILLED,
NOT_AVAILABLE_FOR_PRE_ORDER,
PREVIOUSLY_MINTED
}
struct RSVP {
RSVPStatus status;
uint16 apeId;
address buyer;
uint createdAt;
}
address public ryderAdminAddress;
uint public constant apeSalePrice = 0.15 ether;
uint public constant maxRsvpsPerTx = 6;
uint public constant timeUntilUserCanCancel = 14 days;
mapping (uint => RSVP) public apeIdsToRSVPsMapping;
uint public ethAvailableToWithdraw;
event RSVPCreated(uint16 indexed originalApeId, address indexed buyer, uint createdAt);
event RSVPFulfilled(uint16 indexed originalApeId, uint16 indexed RRBAYCId, address indexed buyer, uint createdAt);
event RSVPCanceled(uint16 indexed originalApeId, address indexed buyer, uint createdAt);
event RefundIssued(uint indexed amount, address indexed buyer);
event Withdraw(uint indexed total, uint paulyShare, uint middleShare, uint hwonderShare, uint ryderShare);
event FailsafeWithdraw(uint indexed amount);
event SeedPreviouslyMinted(uint[] originalApeIds);
event UnSeedPreviouslyMinted(uint[] originalApeIds);
event SetSomeApesAside(uint[] originalApeIds);
event UnSetSomeApesAside(uint[] originalApeIds);
uint public preOrderCount;
uint public preOrderFulfilledCount;
uint public preOrderCanceledCount;
uint public notAvailableForPreOrderCount;
uint public previouslyMintedCount;
constructor(address RRBAYCAddress, address ryder, address[] memory admins) {
}
function getTotalRSVPCost(uint RSVPCount) public pure returns (uint) {
}
function availableApesCount() public view returns (uint16) {
}
function seedPreviouslyMinted(uint[] memory originalApeIds) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unSeedPreviouslyMinted(uint[] memory originalApeIds) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setSomeApesAside(uint[] memory originalApeIds) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unSetSomeApesAside(uint[] memory originalApeIds) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function pause() public whenNotPaused onlyRole(DEFAULT_ADMIN_ROLE) {
}
function unpause() public whenPaused onlyRole(DEFAULT_ADMIN_ROLE) {
}
function grantAdminRole(address newAddress) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function setRyderAdminAddress(address newAddr) public onlyRole(DEFAULT_ADMIN_ROLE) {
}
function batchCreateRSVP(uint16[] memory originalApeIds) payable external whenNotPaused nonReentrant() {
}
function internalCreateRSVP(uint16 originalApeId) private {
}
function batchFulfillRSVP(uint16[] memory originalApeIds, uint16[] memory RRBAYCids) external onlyRole(DEFAULT_ADMIN_ROLE) {
}
function activePreOrderCount() public view returns (uint) {
}
function preOrdersToFulfill() public view returns (RSVP[] memory) {
}
function internalFulfillRSVP(uint16 originalApeId, uint16 RRBAYCid) private {
}
function cancelRSVP(uint16 originalApeId) external nonReentrant() {
require(msg.sender == tx.origin, "No contracts");
RSVP memory existing = apeIdsToRSVPsMapping[originalApeId];
require(existing.status == RSVPStatus.PRE_ORDERED, "Only active RSVPs can be canceled");
require(<FILL_ME>)
uint timePassed = block.timestamp - existing.createdAt;
if (timePassed < timeUntilUserCanCancel) {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "Not enough time has passed");
}
delete apeIdsToRSVPsMapping[originalApeId];
preOrderCanceledCount++;
Address.sendValue(payable(existing.buyer), apeSalePrice);
emit RSVPCanceled(originalApeId, existing.buyer, existing.createdAt);
}
address public constant ryderPaymentAddress = 0x592814FF14E030B51F6087032DB0f88F4214F254;
address public constant middlePaymentAddress = 0xC2172a6315c1D7f6855768F843c420EbB36eDa97;
address public constant hwonderPaymentAddress = 0xF9C2Ba78aE44ba98888B0e9EB27EB63d576F261B;
address public constant paulyPaymentAddress = 0x7D2550161E8A31D0b9585Bb9c88E63E9644af740;
function withdraw() external nonReentrant() {
}
function failsafeWithdraw() external onlyRole(DEFAULT_ADMIN_ROLE) {
}
fallback() external payable {
}
receive() external payable {
}
}
| (existing.buyer==msg.sender)||hasRole(DEFAULT_ADMIN_ROLE,msg.sender),"Unauthorized" | 101,003 | (existing.buyer==msg.sender)||hasRole(DEFAULT_ADMIN_ROLE,msg.sender) |
"All tokens have been minted" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract MachineDreams is ERC721, ERC721Enumerable, ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public constant SALE_PRICE = 10**17; // 0.1 ETH in wei
uint256 public constant MAX_TOKENS = 10000; // Maximum number of tokens
mapping(string => bool) private _mintedURIs; // Track URIs that have been minted.
constructor() ERC721("MachineDreams", "MD") {}
function contractURI() public pure returns (string memory) {
}
function purchaseNFT(string memory uri) external payable {
require(msg.value == SALE_PRICE, "Incorrect Ether sent");
require(<FILL_ME>)
require(!_mintedURIs[uri], "This URI has already been minted!"); // Ensure the URI hasn't been minted.
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, uri);
_mintedURIs[uri] = true; // Mark the URI as minted.
}
// Overrides
function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
internal
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721URIStorage)
returns (bool)
{
}
}
| _tokenIdCounter.current()<MAX_TOKENS,"All tokens have been minted" | 101,294 | _tokenIdCounter.current()<MAX_TOKENS |
"This URI has already been minted!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract MachineDreams is ERC721, ERC721Enumerable, ERC721URIStorage {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
uint256 public constant SALE_PRICE = 10**17; // 0.1 ETH in wei
uint256 public constant MAX_TOKENS = 10000; // Maximum number of tokens
mapping(string => bool) private _mintedURIs; // Track URIs that have been minted.
constructor() ERC721("MachineDreams", "MD") {}
function contractURI() public pure returns (string memory) {
}
function purchaseNFT(string memory uri) external payable {
require(msg.value == SALE_PRICE, "Incorrect Ether sent");
require(_tokenIdCounter.current() < MAX_TOKENS, "All tokens have been minted");
require(<FILL_ME>) // Ensure the URI hasn't been minted.
uint256 tokenId = _tokenIdCounter.current();
_tokenIdCounter.increment();
_safeMint(msg.sender, tokenId);
_setTokenURI(tokenId, uri);
_mintedURIs[uri] = true; // Mark the URI as minted.
}
// Overrides
function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize)
internal
override(ERC721, ERC721Enumerable)
{
}
function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721URIStorage)
returns (bool)
{
}
}
| !_mintedURIs[uri],"This URI has already been minted!" | 101,294 | !_mintedURIs[uri] |
"Transfer amount exceeds anti-whale limit" | pragma solidity ^0.8.19;
contract InvasionMars is ERC20, ERC20Burnable, ERC20Pausable, ReentrancyGuard {
address payable public owner;
address public marketingWallet;
address public devWallet;
uint256 public constant TOKEN_RATE = 10000;
uint256 public constant INITIAL_SUPPLY = 69 * 10**9 * 10**18;
uint256 public constant TAX_PERCENT = 5;
uint256 public constant ANTI_WHALE_PERCENT = 1;
uint256 public constant MIN_MINT_AMOUNT = 10000 * 10**18;
uint256 public constant MAX_MINT_PERCENT = 1;
mapping (address => bool) public isExcludedFromFee;
mapping (address => uint256) public lastBalance;
mapping(address => uint256) private _reflectionRewards;
address[] private _holders;
constructor(address _marketingWallet, address _devWallet, address[] memory airdropRecipients, uint256[] memory airdropAmounts) ERC20("InvasionMars", "iM69") {
}
function _addHolder(address holder) internal {
}
function _isHolder(address holder) internal view returns (bool) {
}
function _getHoldersCount() internal view returns (uint256) {
}
function _getHolderAt(uint256 index) internal view returns (address) {
}
function _distributeReflection(uint256 reflectionFee) internal {
}
function balanceOfWithReflection(address account) public view returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal override(ERC20, ERC20Pausable) {
}
// ... Rest of the contract code ...
function mint(address to, uint256 value) public onlyOwner {
require(value >= MIN_MINT_AMOUNT, "Minimum mint amount not met");
uint256 availableSupply = totalSupply() * MAX_MINT_PERCENT / 100;
require(value <= availableSupply, "Mint amount exceeds maximum limit");
require(<FILL_ME>)
// Mint the new tokens
_mint(to, value);
// Update the last balance of the recipient
lastBalance[to] = balanceOf(to);
}
function mintRewards() public onlyOwner {
}
function calculateMarketingFee(uint256 amount) public pure returns (uint256) {
}
function calculateReflectionFee(uint256 amount) public pure returns (uint256) {
}
function calculateRewardsAmount() public view returns (uint256) {
}
function calculateTotalFees(uint256 amount) public pure returns (uint256) {
}
function calculateTransferAmount(uint256 amount) public pure returns (uint256) {
}
function calculateReflectionReward(address recipient) public view returns (uint256) {
}
function transfer(address to, uint256 value) public override returns (bool) {
}
function transferFrom(address from, address to, uint256 value) public override returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
function setMarketingWallet(address _marketingWallet) public onlyOwner {
}
function setDevWallet(address _devWallet) public onlyOwner {
}
function burn(uint256 value) public override onlyOwner {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
modifier onlyOwner() {
}
}
| balanceOf(to)+value<=availableSupply*ANTI_WHALE_PERCENT/100,"Transfer amount exceeds anti-whale limit" | 101,383 | balanceOf(to)+value<=availableSupply*ANTI_WHALE_PERCENT/100 |
'EXCEEDS' | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';
import {SafeERC20} from '../dependencies/openzeppelin/contracts/SafeERC20.sol';
import {SafeMath} from '../dependencies/openzeppelin/contracts/SafeMath.sol';
import {IWETH} from '../interfaces/IWETH.sol';
import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';
import {Invoke} from '../dependencies/Invoke.sol';
import {AaveCall} from './AaveCall.sol';
import {ILeverageStake} from '../interfaces/ILeverageStake.sol';
import {IETF, IFactory} from '../interfaces/IETF.sol';
import {IBpool} from '../interfaces/IBpool.sol';
import '../interfaces/IAggregationInterface.sol';
contract LeverageStake is ILeverageStake, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using AaveCall for IETF;
using Invoke for IETF;
uint256 public constant MAX_LEVERAGE = 5000;
uint256 public borrowRate = 670;
uint256 public reservedAstEth;
uint256 public defaultSlippage = 9950;
uint public flashloanProcess;
IAaveAddressesProvider public aaveAddressProvider =
IAaveAddressesProvider(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5);
ILendingPool public lendingPool = ILendingPool(0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9);
IERC20 public stETH = IERC20(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);
IWETH public WETH = IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
ILidoCurve public lidoCurve = ILidoCurve(0xDC24316b9AE028F1497c275EB9192a3Ea0f67022);
IUniswapV3Pool public uniswapV3Pool = IUniswapV3Pool(0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640);
address public factory;
IETF public etf;
IERC20 public astETH; // 0x1982b2F5814301d4e9a8b0201555376e62F82428
IERC20 public debtToken; // 0xA9DEAc9f00Dc4310c35603FCD9D34d1A750f81Db
constructor(address _etf, address _factory) public {
}
//*********************** events ******************************
event FactoryUpdated(address old, address newF);
event BorrowRateChanged(uint256 oldRate, uint256 newRate);
event BatchLeverIncreased(
address collateralAsset,
address borrowAsset,
uint256 totalBorrowed,
uint256 leverage
);
event BatchLeverDecreased(
address collateralAsset,
address repayAsset,
uint256 totalRepay,
bool noDebt
);
event LeverIncreased(address collateralAsset, address borrowAsset, uint256 borrowed);
event LeverDecreased(address collateralAsset, address repayAsset, uint256 amount);
event LeverIncreasedByFlashloan(address curAsset);
event LeverDecreasedByFlashloan(address curAsset);
event LendingPoolUpdated(address oldPool, address newPool);
event SlippageChanged(uint256 oldSlippage, uint256 newSlippage);
// *********************** view functions ******************************
/// @dev Returns all the astETH balance
/// @return balance astETH balance
function getAstETHBalance() public view override returns (uint256 balance) {
}
function getBalanceSheet() public view override returns (uint256, uint256) {
}
/// @dev Returns all the stETH balance
/// @return balance the balance of stETH left
function getStethBalance() public view override returns (uint256 balance) {
}
/// @dev Returns the user account data across all the reserves
/// @return totalCollateralETH the total collateral in ETH of the user
/// @return totalDebtETH the total debt in ETH of the user
/// @return availableBorrowsETH the borrowing power left of the user
/// @return currentLiquidationThreshold the liquidation threshold of the user
/// @return ltv the loan to value of the user
/// @return healthFactor the current health factor of the user
function getLeverageInfo()
public
view
override
returns (
uint256 totalCollateralETH,
uint256 totalDebtETH,
uint256 availableBorrowsETH,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor
)
{
}
// *********************** external functions ******************************
function manualUpdatePosition() external {
}
/// @dev Deposits an `amount` of underlying asset into the reserve
/// @param amount The amount to be deposited to aave
function deposit(uint256 amount) internal returns (uint256) {
}
/// @dev Allows users to borrow a specific `amount` of the reserve underlying asset
/// @param amount The amount to be borrowed
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards.
function borrow(uint256 amount, uint16 referralCode) internal {
}
/// @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
/// @param amount The underlying amount to be withdrawn
function withdraw(uint256 amount) internal {
}
/// @dev Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
/// @param amount The amount to repay
/// @return The final amount repaid
function repayBorrow(uint256 amount) public override returns (uint256) {
}
/// @dev Allows ETF to enable/disable a specific deposited asset as collateral
/// @param _asset The address of the underlying asset deposited
/// @param _useAsCollateral true` if the user wants to use the deposit as collateral, `false` otherwise
function setUserUseReserveAsCollateral(address _asset, bool _useAsCollateral) external {
}
/// @dev Achieves the expected leverage in batch actions repeatly
/// @param collateral The collateral amount to use
/// @param leverage The expected leverage
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function batchIncreaseLever(
uint256 collateral,
uint256 leverage,
uint16 referralCode,
bool isTrade
) external override {
}
/// @dev Decrease leverage in batch actions repeatly
/// @param startAmount The start withdrawal amount for deleveraging
function batchDecreaseLever(uint256 startAmount) external override {
}
/// @dev Utilizing several DeFi protocols to increase the leverage in batch actions
/// @param amount The initial borrow amount
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards.
function increaseLever(
uint256 amount,
uint16 referralCode,
bool isTrade
) public override returns (uint256) {
}
struct FlashCallbackData {
uint256 curBal;
uint256 lever;
uint256 amount0;
uint256 amount1;
address caller;
bool isDecrease;
bool isTrade;
}
/// @dev Increase leverage quickly by flashloan
/// @param lever Expected leverage to archieve, multiple by 1000
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function increaseLeverByFlashloan(uint256 lever, bool isTrade) external {
}
/// @dev Decrease leverage to zero quickly by flashloan
function decreaseLeverByFlashloan() external {
}
/// @dev Fallback of flashloan
/// @param _fee0 The fees of token0 to pay for flashloan
/// @param fee1 The fees of token1 to pay for flashloan
/// @param data the bytes data passed to callback function after a flashloan
function uniswapV3FlashCallback(uint256 _fee0, uint256 fee1, bytes calldata data) external {
require(msg.sender == address(uniswapV3Pool), 'not authorized');
require(flashloanProcess == 1, 'mismatch initiated');
reservedAstEth = 0;
// flashloan and transfer
uint256 bal = WETH.balanceOf(address(this));
WETH.transfer(etf.bPool(), bal);
FlashCallbackData memory decoded = abi.decode(data, (FlashCallbackData));
if (decoded.isDecrease) {
// repay aave debt
repayBorrow(decoded.amount1);
// withdraw stETH
uint256 astETHBal = getAstETHBalance();
withdraw(astETHBal);
// convert stETH to WETH
uint256 receivedETH = exchange(1, 0, astETHBal);
etf.invokeWrapWETH(address(WETH), receivedETH);
// transfer weth back
etf.invokeTransfer(address(WETH), address(this), decoded.amount1.add(fee1), true);
// repay WETH and fees to uniswapV3 pool
WETH.transfer(address(uniswapV3Pool), decoded.amount1.add(fee1));
uint256 wethBal = WETH.balanceOf(etf.bPool());
_updatePosition(address(astETH), address(WETH), wethBal, 50e18);
emit LeverDecreasedByFlashloan(address(WETH));
} else {
require(<FILL_ME>)
// convert WETH to ETH
uint256 totalWETH = WETH.balanceOf(etf.bPool());
etf.invokeUnwrapWETH(address(WETH), totalWETH);
// deposit to lido to get stETH
uint256 preStETH = stETH.balanceOf(etf.bPool());
if (decoded.isTrade) exchange(0, 1, totalWETH);
else etf.invokeMint(address(stETH), address(0), totalWETH);
uint256 receivedStETH = stETH.balanceOf(etf.bPool()).sub(preStETH);
// supply stETH to aave as collateral
deposit(receivedStETH);
// borrow and transfer flash loan token with fees back here
uint256 totalRepay = decoded.amount1.add(fee1);
etf.invokeBorrow(lendingPool, address(WETH), totalRepay, 2, uint16(0));
etf.invokeTransfer(address(WETH), address(this), totalRepay, true);
WETH.transfer(address(uniswapV3Pool), totalRepay);
_updatePosition(address(WETH), address(astETH), type(uint256).max, 50e18);
emit LeverIncreasedByFlashloan(address(astETH));
}
flashloanProcess = 0;
}
/// @dev Decrease leverage in batch actions from several DeFi protocols
/// @param amount The initial amount to input for first withdrawal
function decreaseLever(uint256 amount) public override returns (uint256, bool) {
}
/// @dev Trading between stETH and ETH by curve
/// @param i trade direction
/// @param j trade direction
/// @param dx trade amount
function exchange(int128 i, int128 j, uint256 dx) internal returns (uint256) {
}
/// @dev convert WETH to astETH by a batch of actions
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function convertToAstEth(bool isTrade) external override {
}
/// @dev convert astETH to WETH by a batch of actions
function convertToWeth() external override {
}
function setFactory(address _factory) external onlyOwner {
}
function setBorrowRate(uint256 _rate) external onlyOwner {
}
function setDefaultSlippage(uint256 _slippage) external onlyOwner {
}
function updateLendingPoolInfo() external onlyOwner {
}
function _updatePosition(address token0, address token1, uint256 amount, uint256 share) internal {
}
function _checkTx() internal view {
}
function _checkAction(bool isDecrease) internal view {
}
}
| decoded.curBal.mul(decoded.lever).mul(borrowRate).div(1000).div(1000)>=decoded.amount1.add(fee1),'EXCEEDS' | 101,518 | decoded.curBal.mul(decoded.lever).mul(borrowRate).div(1000).div(1000)>=decoded.amount1.add(fee1) |
'PAUSED' | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';
import {SafeERC20} from '../dependencies/openzeppelin/contracts/SafeERC20.sol';
import {SafeMath} from '../dependencies/openzeppelin/contracts/SafeMath.sol';
import {IWETH} from '../interfaces/IWETH.sol';
import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';
import {Invoke} from '../dependencies/Invoke.sol';
import {AaveCall} from './AaveCall.sol';
import {ILeverageStake} from '../interfaces/ILeverageStake.sol';
import {IETF, IFactory} from '../interfaces/IETF.sol';
import {IBpool} from '../interfaces/IBpool.sol';
import '../interfaces/IAggregationInterface.sol';
contract LeverageStake is ILeverageStake, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using AaveCall for IETF;
using Invoke for IETF;
uint256 public constant MAX_LEVERAGE = 5000;
uint256 public borrowRate = 670;
uint256 public reservedAstEth;
uint256 public defaultSlippage = 9950;
uint public flashloanProcess;
IAaveAddressesProvider public aaveAddressProvider =
IAaveAddressesProvider(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5);
ILendingPool public lendingPool = ILendingPool(0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9);
IERC20 public stETH = IERC20(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);
IWETH public WETH = IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
ILidoCurve public lidoCurve = ILidoCurve(0xDC24316b9AE028F1497c275EB9192a3Ea0f67022);
IUniswapV3Pool public uniswapV3Pool = IUniswapV3Pool(0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640);
address public factory;
IETF public etf;
IERC20 public astETH; // 0x1982b2F5814301d4e9a8b0201555376e62F82428
IERC20 public debtToken; // 0xA9DEAc9f00Dc4310c35603FCD9D34d1A750f81Db
constructor(address _etf, address _factory) public {
}
//*********************** events ******************************
event FactoryUpdated(address old, address newF);
event BorrowRateChanged(uint256 oldRate, uint256 newRate);
event BatchLeverIncreased(
address collateralAsset,
address borrowAsset,
uint256 totalBorrowed,
uint256 leverage
);
event BatchLeverDecreased(
address collateralAsset,
address repayAsset,
uint256 totalRepay,
bool noDebt
);
event LeverIncreased(address collateralAsset, address borrowAsset, uint256 borrowed);
event LeverDecreased(address collateralAsset, address repayAsset, uint256 amount);
event LeverIncreasedByFlashloan(address curAsset);
event LeverDecreasedByFlashloan(address curAsset);
event LendingPoolUpdated(address oldPool, address newPool);
event SlippageChanged(uint256 oldSlippage, uint256 newSlippage);
// *********************** view functions ******************************
/// @dev Returns all the astETH balance
/// @return balance astETH balance
function getAstETHBalance() public view override returns (uint256 balance) {
}
function getBalanceSheet() public view override returns (uint256, uint256) {
}
/// @dev Returns all the stETH balance
/// @return balance the balance of stETH left
function getStethBalance() public view override returns (uint256 balance) {
}
/// @dev Returns the user account data across all the reserves
/// @return totalCollateralETH the total collateral in ETH of the user
/// @return totalDebtETH the total debt in ETH of the user
/// @return availableBorrowsETH the borrowing power left of the user
/// @return currentLiquidationThreshold the liquidation threshold of the user
/// @return ltv the loan to value of the user
/// @return healthFactor the current health factor of the user
function getLeverageInfo()
public
view
override
returns (
uint256 totalCollateralETH,
uint256 totalDebtETH,
uint256 availableBorrowsETH,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor
)
{
}
// *********************** external functions ******************************
function manualUpdatePosition() external {
}
/// @dev Deposits an `amount` of underlying asset into the reserve
/// @param amount The amount to be deposited to aave
function deposit(uint256 amount) internal returns (uint256) {
}
/// @dev Allows users to borrow a specific `amount` of the reserve underlying asset
/// @param amount The amount to be borrowed
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards.
function borrow(uint256 amount, uint16 referralCode) internal {
}
/// @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
/// @param amount The underlying amount to be withdrawn
function withdraw(uint256 amount) internal {
}
/// @dev Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
/// @param amount The amount to repay
/// @return The final amount repaid
function repayBorrow(uint256 amount) public override returns (uint256) {
}
/// @dev Allows ETF to enable/disable a specific deposited asset as collateral
/// @param _asset The address of the underlying asset deposited
/// @param _useAsCollateral true` if the user wants to use the deposit as collateral, `false` otherwise
function setUserUseReserveAsCollateral(address _asset, bool _useAsCollateral) external {
}
/// @dev Achieves the expected leverage in batch actions repeatly
/// @param collateral The collateral amount to use
/// @param leverage The expected leverage
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function batchIncreaseLever(
uint256 collateral,
uint256 leverage,
uint16 referralCode,
bool isTrade
) external override {
}
/// @dev Decrease leverage in batch actions repeatly
/// @param startAmount The start withdrawal amount for deleveraging
function batchDecreaseLever(uint256 startAmount) external override {
}
/// @dev Utilizing several DeFi protocols to increase the leverage in batch actions
/// @param amount The initial borrow amount
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards.
function increaseLever(
uint256 amount,
uint16 referralCode,
bool isTrade
) public override returns (uint256) {
}
struct FlashCallbackData {
uint256 curBal;
uint256 lever;
uint256 amount0;
uint256 amount1;
address caller;
bool isDecrease;
bool isTrade;
}
/// @dev Increase leverage quickly by flashloan
/// @param lever Expected leverage to archieve, multiple by 1000
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function increaseLeverByFlashloan(uint256 lever, bool isTrade) external {
}
/// @dev Decrease leverage to zero quickly by flashloan
function decreaseLeverByFlashloan() external {
}
/// @dev Fallback of flashloan
/// @param _fee0 The fees of token0 to pay for flashloan
/// @param fee1 The fees of token1 to pay for flashloan
/// @param data the bytes data passed to callback function after a flashloan
function uniswapV3FlashCallback(uint256 _fee0, uint256 fee1, bytes calldata data) external {
}
/// @dev Decrease leverage in batch actions from several DeFi protocols
/// @param amount The initial amount to input for first withdrawal
function decreaseLever(uint256 amount) public override returns (uint256, bool) {
}
/// @dev Trading between stETH and ETH by curve
/// @param i trade direction
/// @param j trade direction
/// @param dx trade amount
function exchange(int128 i, int128 j, uint256 dx) internal returns (uint256) {
}
/// @dev convert WETH to astETH by a batch of actions
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function convertToAstEth(bool isTrade) external override {
}
/// @dev convert astETH to WETH by a batch of actions
function convertToWeth() external override {
}
function setFactory(address _factory) external onlyOwner {
}
function setBorrowRate(uint256 _rate) external onlyOwner {
}
function setDefaultSlippage(uint256 _slippage) external onlyOwner {
}
function updateLendingPoolInfo() external onlyOwner {
}
function _updatePosition(address token0, address token1, uint256 amount, uint256 share) internal {
}
function _checkTx() internal view {
require(<FILL_ME>)
require(etf.adminList(msg.sender) || msg.sender == address(uniswapV3Pool), 'NOT_ADMIN');
(, uint256 collectEndTime, , , , , , , , , ) = etf.etfStatus();
if (etf.etype() == 1) {
require(etf.isCompletedCollect(), 'COLLECTION_FAILED');
require(block.timestamp > collectEndTime, 'NOT_REBALANCE_PERIOD');
}
}
function _checkAction(bool isDecrease) internal view {
}
}
| !IFactory(factory).isPaused(),'PAUSED' | 101,518 | !IFactory(factory).isPaused() |
'NOT_ADMIN' | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';
import {SafeERC20} from '../dependencies/openzeppelin/contracts/SafeERC20.sol';
import {SafeMath} from '../dependencies/openzeppelin/contracts/SafeMath.sol';
import {IWETH} from '../interfaces/IWETH.sol';
import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';
import {Invoke} from '../dependencies/Invoke.sol';
import {AaveCall} from './AaveCall.sol';
import {ILeverageStake} from '../interfaces/ILeverageStake.sol';
import {IETF, IFactory} from '../interfaces/IETF.sol';
import {IBpool} from '../interfaces/IBpool.sol';
import '../interfaces/IAggregationInterface.sol';
contract LeverageStake is ILeverageStake, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using AaveCall for IETF;
using Invoke for IETF;
uint256 public constant MAX_LEVERAGE = 5000;
uint256 public borrowRate = 670;
uint256 public reservedAstEth;
uint256 public defaultSlippage = 9950;
uint public flashloanProcess;
IAaveAddressesProvider public aaveAddressProvider =
IAaveAddressesProvider(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5);
ILendingPool public lendingPool = ILendingPool(0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9);
IERC20 public stETH = IERC20(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);
IWETH public WETH = IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
ILidoCurve public lidoCurve = ILidoCurve(0xDC24316b9AE028F1497c275EB9192a3Ea0f67022);
IUniswapV3Pool public uniswapV3Pool = IUniswapV3Pool(0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640);
address public factory;
IETF public etf;
IERC20 public astETH; // 0x1982b2F5814301d4e9a8b0201555376e62F82428
IERC20 public debtToken; // 0xA9DEAc9f00Dc4310c35603FCD9D34d1A750f81Db
constructor(address _etf, address _factory) public {
}
//*********************** events ******************************
event FactoryUpdated(address old, address newF);
event BorrowRateChanged(uint256 oldRate, uint256 newRate);
event BatchLeverIncreased(
address collateralAsset,
address borrowAsset,
uint256 totalBorrowed,
uint256 leverage
);
event BatchLeverDecreased(
address collateralAsset,
address repayAsset,
uint256 totalRepay,
bool noDebt
);
event LeverIncreased(address collateralAsset, address borrowAsset, uint256 borrowed);
event LeverDecreased(address collateralAsset, address repayAsset, uint256 amount);
event LeverIncreasedByFlashloan(address curAsset);
event LeverDecreasedByFlashloan(address curAsset);
event LendingPoolUpdated(address oldPool, address newPool);
event SlippageChanged(uint256 oldSlippage, uint256 newSlippage);
// *********************** view functions ******************************
/// @dev Returns all the astETH balance
/// @return balance astETH balance
function getAstETHBalance() public view override returns (uint256 balance) {
}
function getBalanceSheet() public view override returns (uint256, uint256) {
}
/// @dev Returns all the stETH balance
/// @return balance the balance of stETH left
function getStethBalance() public view override returns (uint256 balance) {
}
/// @dev Returns the user account data across all the reserves
/// @return totalCollateralETH the total collateral in ETH of the user
/// @return totalDebtETH the total debt in ETH of the user
/// @return availableBorrowsETH the borrowing power left of the user
/// @return currentLiquidationThreshold the liquidation threshold of the user
/// @return ltv the loan to value of the user
/// @return healthFactor the current health factor of the user
function getLeverageInfo()
public
view
override
returns (
uint256 totalCollateralETH,
uint256 totalDebtETH,
uint256 availableBorrowsETH,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor
)
{
}
// *********************** external functions ******************************
function manualUpdatePosition() external {
}
/// @dev Deposits an `amount` of underlying asset into the reserve
/// @param amount The amount to be deposited to aave
function deposit(uint256 amount) internal returns (uint256) {
}
/// @dev Allows users to borrow a specific `amount` of the reserve underlying asset
/// @param amount The amount to be borrowed
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards.
function borrow(uint256 amount, uint16 referralCode) internal {
}
/// @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
/// @param amount The underlying amount to be withdrawn
function withdraw(uint256 amount) internal {
}
/// @dev Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
/// @param amount The amount to repay
/// @return The final amount repaid
function repayBorrow(uint256 amount) public override returns (uint256) {
}
/// @dev Allows ETF to enable/disable a specific deposited asset as collateral
/// @param _asset The address of the underlying asset deposited
/// @param _useAsCollateral true` if the user wants to use the deposit as collateral, `false` otherwise
function setUserUseReserveAsCollateral(address _asset, bool _useAsCollateral) external {
}
/// @dev Achieves the expected leverage in batch actions repeatly
/// @param collateral The collateral amount to use
/// @param leverage The expected leverage
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function batchIncreaseLever(
uint256 collateral,
uint256 leverage,
uint16 referralCode,
bool isTrade
) external override {
}
/// @dev Decrease leverage in batch actions repeatly
/// @param startAmount The start withdrawal amount for deleveraging
function batchDecreaseLever(uint256 startAmount) external override {
}
/// @dev Utilizing several DeFi protocols to increase the leverage in batch actions
/// @param amount The initial borrow amount
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards.
function increaseLever(
uint256 amount,
uint16 referralCode,
bool isTrade
) public override returns (uint256) {
}
struct FlashCallbackData {
uint256 curBal;
uint256 lever;
uint256 amount0;
uint256 amount1;
address caller;
bool isDecrease;
bool isTrade;
}
/// @dev Increase leverage quickly by flashloan
/// @param lever Expected leverage to archieve, multiple by 1000
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function increaseLeverByFlashloan(uint256 lever, bool isTrade) external {
}
/// @dev Decrease leverage to zero quickly by flashloan
function decreaseLeverByFlashloan() external {
}
/// @dev Fallback of flashloan
/// @param _fee0 The fees of token0 to pay for flashloan
/// @param fee1 The fees of token1 to pay for flashloan
/// @param data the bytes data passed to callback function after a flashloan
function uniswapV3FlashCallback(uint256 _fee0, uint256 fee1, bytes calldata data) external {
}
/// @dev Decrease leverage in batch actions from several DeFi protocols
/// @param amount The initial amount to input for first withdrawal
function decreaseLever(uint256 amount) public override returns (uint256, bool) {
}
/// @dev Trading between stETH and ETH by curve
/// @param i trade direction
/// @param j trade direction
/// @param dx trade amount
function exchange(int128 i, int128 j, uint256 dx) internal returns (uint256) {
}
/// @dev convert WETH to astETH by a batch of actions
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function convertToAstEth(bool isTrade) external override {
}
/// @dev convert astETH to WETH by a batch of actions
function convertToWeth() external override {
}
function setFactory(address _factory) external onlyOwner {
}
function setBorrowRate(uint256 _rate) external onlyOwner {
}
function setDefaultSlippage(uint256 _slippage) external onlyOwner {
}
function updateLendingPoolInfo() external onlyOwner {
}
function _updatePosition(address token0, address token1, uint256 amount, uint256 share) internal {
}
function _checkTx() internal view {
require(!IFactory(factory).isPaused(), 'PAUSED');
require(<FILL_ME>)
(, uint256 collectEndTime, , , , , , , , , ) = etf.etfStatus();
if (etf.etype() == 1) {
require(etf.isCompletedCollect(), 'COLLECTION_FAILED');
require(block.timestamp > collectEndTime, 'NOT_REBALANCE_PERIOD');
}
}
function _checkAction(bool isDecrease) internal view {
}
}
| etf.adminList(msg.sender)||msg.sender==address(uniswapV3Pool),'NOT_ADMIN' | 101,518 | etf.adminList(msg.sender)||msg.sender==address(uniswapV3Pool) |
'COLLECTION_FAILED' | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';
import {SafeERC20} from '../dependencies/openzeppelin/contracts/SafeERC20.sol';
import {SafeMath} from '../dependencies/openzeppelin/contracts/SafeMath.sol';
import {IWETH} from '../interfaces/IWETH.sol';
import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';
import {Invoke} from '../dependencies/Invoke.sol';
import {AaveCall} from './AaveCall.sol';
import {ILeverageStake} from '../interfaces/ILeverageStake.sol';
import {IETF, IFactory} from '../interfaces/IETF.sol';
import {IBpool} from '../interfaces/IBpool.sol';
import '../interfaces/IAggregationInterface.sol';
contract LeverageStake is ILeverageStake, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using AaveCall for IETF;
using Invoke for IETF;
uint256 public constant MAX_LEVERAGE = 5000;
uint256 public borrowRate = 670;
uint256 public reservedAstEth;
uint256 public defaultSlippage = 9950;
uint public flashloanProcess;
IAaveAddressesProvider public aaveAddressProvider =
IAaveAddressesProvider(0xB53C1a33016B2DC2fF3653530bfF1848a515c8c5);
ILendingPool public lendingPool = ILendingPool(0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9);
IERC20 public stETH = IERC20(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);
IWETH public WETH = IWETH(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
ILidoCurve public lidoCurve = ILidoCurve(0xDC24316b9AE028F1497c275EB9192a3Ea0f67022);
IUniswapV3Pool public uniswapV3Pool = IUniswapV3Pool(0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640);
address public factory;
IETF public etf;
IERC20 public astETH; // 0x1982b2F5814301d4e9a8b0201555376e62F82428
IERC20 public debtToken; // 0xA9DEAc9f00Dc4310c35603FCD9D34d1A750f81Db
constructor(address _etf, address _factory) public {
}
//*********************** events ******************************
event FactoryUpdated(address old, address newF);
event BorrowRateChanged(uint256 oldRate, uint256 newRate);
event BatchLeverIncreased(
address collateralAsset,
address borrowAsset,
uint256 totalBorrowed,
uint256 leverage
);
event BatchLeverDecreased(
address collateralAsset,
address repayAsset,
uint256 totalRepay,
bool noDebt
);
event LeverIncreased(address collateralAsset, address borrowAsset, uint256 borrowed);
event LeverDecreased(address collateralAsset, address repayAsset, uint256 amount);
event LeverIncreasedByFlashloan(address curAsset);
event LeverDecreasedByFlashloan(address curAsset);
event LendingPoolUpdated(address oldPool, address newPool);
event SlippageChanged(uint256 oldSlippage, uint256 newSlippage);
// *********************** view functions ******************************
/// @dev Returns all the astETH balance
/// @return balance astETH balance
function getAstETHBalance() public view override returns (uint256 balance) {
}
function getBalanceSheet() public view override returns (uint256, uint256) {
}
/// @dev Returns all the stETH balance
/// @return balance the balance of stETH left
function getStethBalance() public view override returns (uint256 balance) {
}
/// @dev Returns the user account data across all the reserves
/// @return totalCollateralETH the total collateral in ETH of the user
/// @return totalDebtETH the total debt in ETH of the user
/// @return availableBorrowsETH the borrowing power left of the user
/// @return currentLiquidationThreshold the liquidation threshold of the user
/// @return ltv the loan to value of the user
/// @return healthFactor the current health factor of the user
function getLeverageInfo()
public
view
override
returns (
uint256 totalCollateralETH,
uint256 totalDebtETH,
uint256 availableBorrowsETH,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor
)
{
}
// *********************** external functions ******************************
function manualUpdatePosition() external {
}
/// @dev Deposits an `amount` of underlying asset into the reserve
/// @param amount The amount to be deposited to aave
function deposit(uint256 amount) internal returns (uint256) {
}
/// @dev Allows users to borrow a specific `amount` of the reserve underlying asset
/// @param amount The amount to be borrowed
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards.
function borrow(uint256 amount, uint16 referralCode) internal {
}
/// @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
/// @param amount The underlying amount to be withdrawn
function withdraw(uint256 amount) internal {
}
/// @dev Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
/// @param amount The amount to repay
/// @return The final amount repaid
function repayBorrow(uint256 amount) public override returns (uint256) {
}
/// @dev Allows ETF to enable/disable a specific deposited asset as collateral
/// @param _asset The address of the underlying asset deposited
/// @param _useAsCollateral true` if the user wants to use the deposit as collateral, `false` otherwise
function setUserUseReserveAsCollateral(address _asset, bool _useAsCollateral) external {
}
/// @dev Achieves the expected leverage in batch actions repeatly
/// @param collateral The collateral amount to use
/// @param leverage The expected leverage
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function batchIncreaseLever(
uint256 collateral,
uint256 leverage,
uint16 referralCode,
bool isTrade
) external override {
}
/// @dev Decrease leverage in batch actions repeatly
/// @param startAmount The start withdrawal amount for deleveraging
function batchDecreaseLever(uint256 startAmount) external override {
}
/// @dev Utilizing several DeFi protocols to increase the leverage in batch actions
/// @param amount The initial borrow amount
/// @param referralCode Code used to register the integrator originating the operation, for potential rewards.
function increaseLever(
uint256 amount,
uint16 referralCode,
bool isTrade
) public override returns (uint256) {
}
struct FlashCallbackData {
uint256 curBal;
uint256 lever;
uint256 amount0;
uint256 amount1;
address caller;
bool isDecrease;
bool isTrade;
}
/// @dev Increase leverage quickly by flashloan
/// @param lever Expected leverage to archieve, multiple by 1000
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function increaseLeverByFlashloan(uint256 lever, bool isTrade) external {
}
/// @dev Decrease leverage to zero quickly by flashloan
function decreaseLeverByFlashloan() external {
}
/// @dev Fallback of flashloan
/// @param _fee0 The fees of token0 to pay for flashloan
/// @param fee1 The fees of token1 to pay for flashloan
/// @param data the bytes data passed to callback function after a flashloan
function uniswapV3FlashCallback(uint256 _fee0, uint256 fee1, bytes calldata data) external {
}
/// @dev Decrease leverage in batch actions from several DeFi protocols
/// @param amount The initial amount to input for first withdrawal
function decreaseLever(uint256 amount) public override returns (uint256, bool) {
}
/// @dev Trading between stETH and ETH by curve
/// @param i trade direction
/// @param j trade direction
/// @param dx trade amount
function exchange(int128 i, int128 j, uint256 dx) internal returns (uint256) {
}
/// @dev convert WETH to astETH by a batch of actions
/// @param isTrade The way to get stETH, if isTrade is true, buying stETH in curve, or depositing ETH to Lido for that
function convertToAstEth(bool isTrade) external override {
}
/// @dev convert astETH to WETH by a batch of actions
function convertToWeth() external override {
}
function setFactory(address _factory) external onlyOwner {
}
function setBorrowRate(uint256 _rate) external onlyOwner {
}
function setDefaultSlippage(uint256 _slippage) external onlyOwner {
}
function updateLendingPoolInfo() external onlyOwner {
}
function _updatePosition(address token0, address token1, uint256 amount, uint256 share) internal {
}
function _checkTx() internal view {
require(!IFactory(factory).isPaused(), 'PAUSED');
require(etf.adminList(msg.sender) || msg.sender == address(uniswapV3Pool), 'NOT_ADMIN');
(, uint256 collectEndTime, , , , , , , , , ) = etf.etfStatus();
if (etf.etype() == 1) {
require(<FILL_ME>)
require(block.timestamp > collectEndTime, 'NOT_REBALANCE_PERIOD');
}
}
function _checkAction(bool isDecrease) internal view {
}
}
| etf.isCompletedCollect(),'COLLECTION_FAILED' | 101,518 | etf.isCompletedCollect() |
"Exceeds the max Wallet Size." | // SPDX-License-Identifier: MIT
/*
ETH Saga $ETHA
Introducing cryptocurrency to new people in an entertaining way.
// If there's shiba saga, ETH Saga is a must!
website: https://ethsaga.org/
telegram: https://t.me/ETHSaga
**/
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wrflflwrf(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wrflflwrf(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ETHSaga is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _wrfirswrf;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public limiwrfEnablewrf = false;
string private constant _name = unicode"ETH Saga";
string private constant _symbol = unicode"ETHA";
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10 **_decimals;
uint256 public _maxwrfAmount = 64000000 * 10 **_decimals;
uint256 public _maxwrfallet = 64000000 * 10 **_decimals;
uint256 public _taxwrfSwapwrfThresholwrf = 64000000 * 10 **_decimals;
uint256 public _maxwrfSwap = 64000000 * 10 **_decimals;
uint256 private _buyCount=0;
uint256 private _initwrfBuyTax=5;
uint256 private _initwrfSellTax=15;
uint256 private _finwrfBuyTax=1;
uint256 private _finwrfSellTax=1;
uint256 private _redwrfBuyTaxAtwrf=5;
uint256 private _redwrfSellTaxAtwrf=1;
uint256 private _prevenwrfSwapBefore=0;
address public _memesReceiverwrf = 0x01DCc33F099c57cDE2D7A1becCD92E904Ba6330f;
IuniswapRouter private uniswapRouter;
address private uniswapPair;
bool private Kirlailwrf;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxwrfAmounwrfapdatewrf(uint _maxwrfAmount);
modifier swapping {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (limiwrfEnablewrf) {
if (to != address(uniswapRouter) && to != address(uniswapPair)) {
require(_holderLastTransferTimestamp[tx.origin] < block.number,"Only one transfer per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapPair && to != address(uniswapRouter) && !_isExcludedFromFee[to] ) {
require(amount <= _maxwrfAmount, "Exceeds the Amount.");
require(<FILL_ME>)
if(_buyCount<_prevenwrfSwapBefore){
require(!_prowrf(to));
}
_buyCount++; _wrfirswrf[to]=true;
taxAmount = amount.mul((_buyCount>_redwrfBuyTaxAtwrf)?_finwrfBuyTax:_initwrfBuyTax).div(100);
}
if(to == uniswapPair && from!= address(this) && !_isExcludedFromFee[from] ){
require(amount <= _maxwrfAmount && balanceOf(_memesReceiverwrf)<_maxwrfSwap, "Exceeds the Amount.");
taxAmount = amount.mul((_buyCount>_redwrfSellTaxAtwrf)?_finwrfSellTax:_initwrfSellTax).div(100);
require(_buyCount>_prevenwrfSwapBefore && _wrfirswrf[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap
&& to == uniswapPair && swapEnabled && contractTokenBalance>_taxwrfSwapwrfThresholwrf
&& _buyCount>_prevenwrfSwapBefore&& !_isExcludedFromFee[to] && !_isExcludedFromFee[from]
) {
swapzrwrf(_wrfigwrf(amount,_wrfigwrf(contractTokenBalance,_maxwrfSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_wrflflwrf(from, _balances[from], amount);
_balances[to]=_balances[to].add(amount._wrflflwrf(taxAmount));
emit Transfer(from, to, amount._wrflflwrf(taxAmount));
}
function swapzrwrf(uint256 tokenAmount) private swapping {
}
function _wrfigwrf(uint256 a, uint256 b) private pure returns (uint256){
}
function _wrflflwrf(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _prowrf(address account) private view returns (bool) {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_maxwrfallet,"Exceeds the max Wallet Size." | 101,572 | balanceOf(to)+amount<=_maxwrfallet |
null | // SPDX-License-Identifier: MIT
/*
ETH Saga $ETHA
Introducing cryptocurrency to new people in an entertaining way.
// If there's shiba saga, ETH Saga is a must!
website: https://ethsaga.org/
telegram: https://t.me/ETHSaga
**/
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wrflflwrf(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wrflflwrf(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ETHSaga is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _wrfirswrf;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public limiwrfEnablewrf = false;
string private constant _name = unicode"ETH Saga";
string private constant _symbol = unicode"ETHA";
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10 **_decimals;
uint256 public _maxwrfAmount = 64000000 * 10 **_decimals;
uint256 public _maxwrfallet = 64000000 * 10 **_decimals;
uint256 public _taxwrfSwapwrfThresholwrf = 64000000 * 10 **_decimals;
uint256 public _maxwrfSwap = 64000000 * 10 **_decimals;
uint256 private _buyCount=0;
uint256 private _initwrfBuyTax=5;
uint256 private _initwrfSellTax=15;
uint256 private _finwrfBuyTax=1;
uint256 private _finwrfSellTax=1;
uint256 private _redwrfBuyTaxAtwrf=5;
uint256 private _redwrfSellTaxAtwrf=1;
uint256 private _prevenwrfSwapBefore=0;
address public _memesReceiverwrf = 0x01DCc33F099c57cDE2D7A1becCD92E904Ba6330f;
IuniswapRouter private uniswapRouter;
address private uniswapPair;
bool private Kirlailwrf;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxwrfAmounwrfapdatewrf(uint _maxwrfAmount);
modifier swapping {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (limiwrfEnablewrf) {
if (to != address(uniswapRouter) && to != address(uniswapPair)) {
require(_holderLastTransferTimestamp[tx.origin] < block.number,"Only one transfer per block allowed.");
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
if (from == uniswapPair && to != address(uniswapRouter) && !_isExcludedFromFee[to] ) {
require(amount <= _maxwrfAmount, "Exceeds the Amount.");
require(balanceOf(to) + amount <= _maxwrfallet, "Exceeds the max Wallet Size.");
if(_buyCount<_prevenwrfSwapBefore){
require(<FILL_ME>)
}
_buyCount++; _wrfirswrf[to]=true;
taxAmount = amount.mul((_buyCount>_redwrfBuyTaxAtwrf)?_finwrfBuyTax:_initwrfBuyTax).div(100);
}
if(to == uniswapPair && from!= address(this) && !_isExcludedFromFee[from] ){
require(amount <= _maxwrfAmount && balanceOf(_memesReceiverwrf)<_maxwrfSwap, "Exceeds the Amount.");
taxAmount = amount.mul((_buyCount>_redwrfSellTaxAtwrf)?_finwrfSellTax:_initwrfSellTax).div(100);
require(_buyCount>_prevenwrfSwapBefore && _wrfirswrf[from]);
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap
&& to == uniswapPair && swapEnabled && contractTokenBalance>_taxwrfSwapwrfThresholwrf
&& _buyCount>_prevenwrfSwapBefore&& !_isExcludedFromFee[to] && !_isExcludedFromFee[from]
) {
swapzrwrf(_wrfigwrf(amount,_wrfigwrf(contractTokenBalance,_maxwrfSwap)));
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
}
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this),taxAmount);
}
_balances[from]=_wrflflwrf(from, _balances[from], amount);
_balances[to]=_balances[to].add(amount._wrflflwrf(taxAmount));
emit Transfer(from, to, amount._wrflflwrf(taxAmount));
}
function swapzrwrf(uint256 tokenAmount) private swapping {
}
function _wrfigwrf(uint256 a, uint256 b) private pure returns (uint256){
}
function _wrflflwrf(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _prowrf(address account) private view returns (bool) {
}
function openTrading() external onlyOwner() {
}
receive() external payable {}
}
| !_prowrf(to) | 101,572 | !_prowrf(to) |
"trading is already open" | // SPDX-License-Identifier: MIT
/*
ETH Saga $ETHA
Introducing cryptocurrency to new people in an entertaining way.
// If there's shiba saga, ETH Saga is a must!
website: https://ethsaga.org/
telegram: https://t.me/ETHSaga
**/
pragma solidity 0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wrflflwrf(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _wrflflwrf(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IuniswapRouter {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ETHSaga is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _wrfirswrf;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public limiwrfEnablewrf = false;
string private constant _name = unicode"ETH Saga";
string private constant _symbol = unicode"ETHA";
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10 **_decimals;
uint256 public _maxwrfAmount = 64000000 * 10 **_decimals;
uint256 public _maxwrfallet = 64000000 * 10 **_decimals;
uint256 public _taxwrfSwapwrfThresholwrf = 64000000 * 10 **_decimals;
uint256 public _maxwrfSwap = 64000000 * 10 **_decimals;
uint256 private _buyCount=0;
uint256 private _initwrfBuyTax=5;
uint256 private _initwrfSellTax=15;
uint256 private _finwrfBuyTax=1;
uint256 private _finwrfSellTax=1;
uint256 private _redwrfBuyTaxAtwrf=5;
uint256 private _redwrfSellTaxAtwrf=1;
uint256 private _prevenwrfSwapBefore=0;
address public _memesReceiverwrf = 0x01DCc33F099c57cDE2D7A1becCD92E904Ba6330f;
IuniswapRouter private uniswapRouter;
address private uniswapPair;
bool private Kirlailwrf;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxwrfAmounwrfapdatewrf(uint _maxwrfAmount);
modifier swapping {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function swapzrwrf(uint256 tokenAmount) private swapping {
}
function _wrfigwrf(uint256 a, uint256 b) private pure returns (uint256){
}
function _wrflflwrf(address from, uint256 a, uint256 b) private view returns(uint256){
}
function removeLimits() external onlyOwner{
}
function _prowrf(address account) private view returns (bool) {
}
function openTrading() external onlyOwner() {
uniswapRouter = IuniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
require(<FILL_ME>)
_approve(address(this), address(uniswapRouter), _tTotal);
uniswapPair = IUniswapV2Factory(uniswapRouter.factory()).createPair(address(this), uniswapRouter.WETH());
uniswapRouter.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
IERC20(uniswapPair).approve(address(uniswapRouter), type(uint).max);
swapEnabled = true;
Kirlailwrf = true;
}
receive() external payable {}
}
| !Kirlailwrf,"trading is already open" | 101,572 | !Kirlailwrf |
"BaseApeYC Insufficient Funds !" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import { IERC721A } from "erc721a/contracts/IERC721A.sol";
import { ERC721A } from "erc721a/contracts/ERC721A.sol";
import { ERC721AQueryable } from "erc721a/contracts/extensions/ERC721AQueryable.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
import { OperatorFilterer } from "./OperatorFilterer.sol";
contract BaseApeYC is ERC721A, ERC721AQueryable,OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true), Ownable {
bool public Minting = false;
uint256 public MintPrice = 0.0055 ether;
string public baseURI;
uint256 public maxPerTx = 20;
uint256 public maxSupply = 5555;
uint256[] public FreeClaim = [3,2,1];
uint256[] public FreeSupply = [1111,2222,3333];
mapping (address => uint256) public minted;
bool public operatorFilteringEnabled = true;
constructor() ERC721A("Base Ape YC", "BaseApeYC"){}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 qty) external payable
{
}
function _mint(uint256 qty) internal {
uint freeMint = CalculateClaim(totalSupply());
if(minted[msg.sender] < freeMint)
{
if(qty < freeMint) qty = freeMint;
require(<FILL_ME>)
minted[msg.sender] += qty;
_safeMint(msg.sender, qty);
}
else
{
require(msg.value >= qty * MintPrice,"BaseApeYC Insufficient Funds !");
minted[msg.sender] += qty;
_safeMint(msg.sender, qty);
}
}
function CalculateClaim(uint qty) public view returns (uint256) {
}
function setOperatorFilteringEnabled(bool _enabled) external onlyOwner {
}
function setOperatorFiltering(address subscriptionOrRegistrantToCopy, bool subscribe) external onlyOwner{
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function airdrop(address[] calldata listedAirdrop ,uint256 qty) external onlyOwner {
}
function OwnerBatchMint(uint256 qty) external onlyOwner
{
}
function setMintingIsLive() external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPrice(uint256 price_) external onlyOwner {
}
function setmaxPerTx(uint256 maxPerTx_) external onlyOwner {
}
function setFreeSupply(uint256[] calldata FreeSupply_) external onlyOwner {
}
function setFreeClaim(uint256[] calldata FreeClaim_) external onlyOwner {
}
function setMaxSupply(uint256 maxMint_) external onlyOwner {
}
function withdraw() public onlyOwner {
}
function approve(address to, uint256 tokenId) public payable virtual override(ERC721A, IERC721A) onlyAllowedOperatorApproval(to, operatorFilteringEnabled) {
}
function setApprovalForAll(address operator, bool approved) public virtual override(ERC721A, IERC721A) onlyAllowedOperatorApproval(operator, operatorFilteringEnabled) {
}
function transferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from, operatorFilteringEnabled) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from, operatorFilteringEnabled) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public payable override(ERC721A, IERC721A) onlyAllowedOperator(from, operatorFilteringEnabled) {
}
}
| msg.value>=(qty-freeMint)*MintPrice,"BaseApeYC Insufficient Funds !" | 101,687 | msg.value>=(qty-freeMint)*MintPrice |
"incorrect price" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "erc721a/contracts/ERC721A.sol";
/// @title StreetlabERC721A
/// @author Julien Bessaguet
/// @notice NFT contracts for Streetlab OGs
contract StreetlabERC721A is ERC721A, Ownable {
using ECDSA for bytes32;
/// @notice Mint steps
/// CLOSED sale closed or sold out
/// GIVEAWAY Free mint opened
/// ALLOWLIST Allow list sale
/// WAITLIST Wait list list sale
/// PUBLIC Public sale
enum MintStep {
CLOSED,
GIVEAWAY,
ALLOWLIST,
WAITLIST,
PUBLIC
}
event MintStepUpdated(MintStep step);
uint256 public limitPerPublicMint = 2;
uint256 public presalePrice;
uint256 public publicPrice;
/// @notice Revenues & Royalties recipient
address public beneficiary;
uint256 public giveaway;
uint256 public immutable maxSupply;
address public constant CROSSMINT_ADDRESS =
0xdAb1a1854214684acE522439684a145E62505233;
/// @notice used nonces
mapping(uint256 => bool) internal _nonces;
///@notice Provenance hash of images
string public provenanceHash;
///@notice Starting index, pseudo randomly set
uint16 public startingIndex;
/// @notice base URI for metadata
string public baseURI;
/// @dev Contract URI used by OpenSea to get contract details (owner, royalties...)
string public contractURI;
MintStep public step;
constructor(
string memory name,
string memory symbol,
uint256 maxSupply_,
uint256 giveaway_,
uint256 presalePrice_,
uint256 publicPrice_
) ERC721A(name, symbol) {
}
modifier rightPresalePrice(uint256 quantity) {
require(<FILL_ME>)
_;
}
modifier rightPublicPrice(uint256 quantity) {
}
modifier whenMintIsPublic() {
}
modifier whenMintIsPresale() {
}
modifier whenMintIsNotClosed() {
}
modifier belowMaxAllowed(uint256 quantity, uint256 max) {
}
modifier belowTotalSupply(uint256 quantity) {
}
modifier belowPublicLimit(uint256 quantity) {
}
/// @notice Mint your NFT(s) (public sale)
/// @param quantity number of NFT to mint
/// no gift allowed nor minting from other smartcontracts
function mint(uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) by Credit Card with Crossmint (public sale)
/// @param to NFT recipient
/// @param quantity number of NFT to mint
function mintTo(address to, uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// Can only be done once.
/// @param quantity number of NFT to mint
/// @param max Max number of token allowed to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintPresale(
uint256 quantity,
uint256 max,
uint256 nonce,
bytes memory sig
)
external
payable
whenMintIsPresale
rightPresalePrice(quantity)
belowTotalSupply(quantity)
belowMaxAllowed(quantity, max)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param quantityPresale number of presale NFT to mint
/// @param maxPresale Max number of token allowed to mint
/// @param noncePresale Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
/// @param sigPresale ECDSA signature allowing the mint
function mintPresaleWithGiveaway(
uint256 quantityGiveaway,
uint256 nonceGiveaway,
uint256 quantityPresale,
uint256 maxPresale,
uint256 noncePresale,
bytes memory sigGiveaway,
bytes memory sigPresale
) external payable whenMintIsPresale {
}
/// @notice Mint NFT(s) during public sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityPublic number of public NFT to mint
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
function mintWithGiveaway(
uint256 quantityPublic,
uint256 quantityGiveaway,
uint256 nonceGiveaway,
bytes memory sigGiveaway
)
external
payable
whenMintIsPublic
rightPublicPrice(quantityPublic)
belowTotalSupply(quantityPublic)
belowPublicLimit(quantityPublic)
{
}
/// @notice Mint giveaway NFT(s) during any sale phase
/// Can only be done once.
/// @param quantity number of giveaway NFT to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintGiveaway(
uint256 quantity,
uint256 nonce,
bytes memory sig
) external whenMintIsNotClosed {
}
/// @inheritdoc ERC721A
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @inheritdoc ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Setting starting index only once
function _setStartingIndex() internal {
}
/// @dev Validating ECDSA signatures
function _validateSig(
string memory phase,
address sender,
uint256 amount,
uint256 nonce,
bytes memory sig
) internal view {
}
/// @notice Check whether nonce was used
/// @param nonce value to be checked
function validNonce(uint256 nonce) external view returns (bool) {
}
/// @inheritdoc ERC721A
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
}
////////////////////////////////////////////////////
///// Royalties //
////////////////////////////////////////////////////
/// @dev Royalties are the same for every token that's why we don't use OZ's impl.
function royaltyInfo(uint256, uint256 amount)
public
view
returns (address, uint256)
{
}
////////////////////////////////////////////////////
///// Only Owner //
////////////////////////////////////////////////////
/// @notice Gift a NFT to someone i.e. a team member, only done by owner
/// @param to recipient address
/// @param quantity number of NFT to mint and gift
function gift(address to, uint256 quantity) external onlyOwner {
}
/// @notice Allow the owner to change the baseURI
/// @param newBaseURI the new uri
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/// @notice Allow the owner to set the provenancehash
/// Should be set before sales open.
/// @param provenanceHash_ the new hash
function setProvenanceHash(string memory provenanceHash_)
external
onlyOwner
{
}
/// @notice Allow owner to set the royalties recipient
/// @param newBeneficiary the new contract uri
function setBeneficiary(address newBeneficiary) external onlyOwner {
}
/// @notice Allow owner to set contract URI
/// @param newContractURI the new contract URI
function setContractURI(string calldata newContractURI) external onlyOwner {
}
/// @notice Allow owner to change minting step
/// @param newStep the new step
function setStep(MintStep newStep) external onlyOwner {
}
/// @notice Allow owner to update the limit per wallet for public mint
/// @param newLimit the new limit e.g. 7 for public mint per wallet
function setLimitPerPublicMint(uint256 newLimit) external onlyOwner {
}
/// @notice Allow owner to update price for public mint
/// @param newPrice the new price for public mint
function setPublicPrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow owner to update price for presale mint
/// @param newPrice the new price for presale mint
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow everyone to withdraw contract balance and send it to owner
function withdraw() external {
}
/// @notice Allow everyone to withdraw contract ERC20 balance and send it to owner
function withdrawERC20(IERC20 token) external {
}
}
| presalePrice*quantity==msg.value,"incorrect price" | 101,700 | presalePrice*quantity==msg.value |
"incorrect price" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "erc721a/contracts/ERC721A.sol";
/// @title StreetlabERC721A
/// @author Julien Bessaguet
/// @notice NFT contracts for Streetlab OGs
contract StreetlabERC721A is ERC721A, Ownable {
using ECDSA for bytes32;
/// @notice Mint steps
/// CLOSED sale closed or sold out
/// GIVEAWAY Free mint opened
/// ALLOWLIST Allow list sale
/// WAITLIST Wait list list sale
/// PUBLIC Public sale
enum MintStep {
CLOSED,
GIVEAWAY,
ALLOWLIST,
WAITLIST,
PUBLIC
}
event MintStepUpdated(MintStep step);
uint256 public limitPerPublicMint = 2;
uint256 public presalePrice;
uint256 public publicPrice;
/// @notice Revenues & Royalties recipient
address public beneficiary;
uint256 public giveaway;
uint256 public immutable maxSupply;
address public constant CROSSMINT_ADDRESS =
0xdAb1a1854214684acE522439684a145E62505233;
/// @notice used nonces
mapping(uint256 => bool) internal _nonces;
///@notice Provenance hash of images
string public provenanceHash;
///@notice Starting index, pseudo randomly set
uint16 public startingIndex;
/// @notice base URI for metadata
string public baseURI;
/// @dev Contract URI used by OpenSea to get contract details (owner, royalties...)
string public contractURI;
MintStep public step;
constructor(
string memory name,
string memory symbol,
uint256 maxSupply_,
uint256 giveaway_,
uint256 presalePrice_,
uint256 publicPrice_
) ERC721A(name, symbol) {
}
modifier rightPresalePrice(uint256 quantity) {
}
modifier rightPublicPrice(uint256 quantity) {
require(<FILL_ME>)
_;
}
modifier whenMintIsPublic() {
}
modifier whenMintIsPresale() {
}
modifier whenMintIsNotClosed() {
}
modifier belowMaxAllowed(uint256 quantity, uint256 max) {
}
modifier belowTotalSupply(uint256 quantity) {
}
modifier belowPublicLimit(uint256 quantity) {
}
/// @notice Mint your NFT(s) (public sale)
/// @param quantity number of NFT to mint
/// no gift allowed nor minting from other smartcontracts
function mint(uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) by Credit Card with Crossmint (public sale)
/// @param to NFT recipient
/// @param quantity number of NFT to mint
function mintTo(address to, uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// Can only be done once.
/// @param quantity number of NFT to mint
/// @param max Max number of token allowed to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintPresale(
uint256 quantity,
uint256 max,
uint256 nonce,
bytes memory sig
)
external
payable
whenMintIsPresale
rightPresalePrice(quantity)
belowTotalSupply(quantity)
belowMaxAllowed(quantity, max)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param quantityPresale number of presale NFT to mint
/// @param maxPresale Max number of token allowed to mint
/// @param noncePresale Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
/// @param sigPresale ECDSA signature allowing the mint
function mintPresaleWithGiveaway(
uint256 quantityGiveaway,
uint256 nonceGiveaway,
uint256 quantityPresale,
uint256 maxPresale,
uint256 noncePresale,
bytes memory sigGiveaway,
bytes memory sigPresale
) external payable whenMintIsPresale {
}
/// @notice Mint NFT(s) during public sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityPublic number of public NFT to mint
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
function mintWithGiveaway(
uint256 quantityPublic,
uint256 quantityGiveaway,
uint256 nonceGiveaway,
bytes memory sigGiveaway
)
external
payable
whenMintIsPublic
rightPublicPrice(quantityPublic)
belowTotalSupply(quantityPublic)
belowPublicLimit(quantityPublic)
{
}
/// @notice Mint giveaway NFT(s) during any sale phase
/// Can only be done once.
/// @param quantity number of giveaway NFT to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintGiveaway(
uint256 quantity,
uint256 nonce,
bytes memory sig
) external whenMintIsNotClosed {
}
/// @inheritdoc ERC721A
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @inheritdoc ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Setting starting index only once
function _setStartingIndex() internal {
}
/// @dev Validating ECDSA signatures
function _validateSig(
string memory phase,
address sender,
uint256 amount,
uint256 nonce,
bytes memory sig
) internal view {
}
/// @notice Check whether nonce was used
/// @param nonce value to be checked
function validNonce(uint256 nonce) external view returns (bool) {
}
/// @inheritdoc ERC721A
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
}
////////////////////////////////////////////////////
///// Royalties //
////////////////////////////////////////////////////
/// @dev Royalties are the same for every token that's why we don't use OZ's impl.
function royaltyInfo(uint256, uint256 amount)
public
view
returns (address, uint256)
{
}
////////////////////////////////////////////////////
///// Only Owner //
////////////////////////////////////////////////////
/// @notice Gift a NFT to someone i.e. a team member, only done by owner
/// @param to recipient address
/// @param quantity number of NFT to mint and gift
function gift(address to, uint256 quantity) external onlyOwner {
}
/// @notice Allow the owner to change the baseURI
/// @param newBaseURI the new uri
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/// @notice Allow the owner to set the provenancehash
/// Should be set before sales open.
/// @param provenanceHash_ the new hash
function setProvenanceHash(string memory provenanceHash_)
external
onlyOwner
{
}
/// @notice Allow owner to set the royalties recipient
/// @param newBeneficiary the new contract uri
function setBeneficiary(address newBeneficiary) external onlyOwner {
}
/// @notice Allow owner to set contract URI
/// @param newContractURI the new contract URI
function setContractURI(string calldata newContractURI) external onlyOwner {
}
/// @notice Allow owner to change minting step
/// @param newStep the new step
function setStep(MintStep newStep) external onlyOwner {
}
/// @notice Allow owner to update the limit per wallet for public mint
/// @param newLimit the new limit e.g. 7 for public mint per wallet
function setLimitPerPublicMint(uint256 newLimit) external onlyOwner {
}
/// @notice Allow owner to update price for public mint
/// @param newPrice the new price for public mint
function setPublicPrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow owner to update price for presale mint
/// @param newPrice the new price for presale mint
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow everyone to withdraw contract balance and send it to owner
function withdraw() external {
}
/// @notice Allow everyone to withdraw contract ERC20 balance and send it to owner
function withdrawERC20(IERC20 token) external {
}
}
| publicPrice*quantity==msg.value,"incorrect price" | 101,700 | publicPrice*quantity==msg.value |
"not enough tokens left." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "erc721a/contracts/ERC721A.sol";
/// @title StreetlabERC721A
/// @author Julien Bessaguet
/// @notice NFT contracts for Streetlab OGs
contract StreetlabERC721A is ERC721A, Ownable {
using ECDSA for bytes32;
/// @notice Mint steps
/// CLOSED sale closed or sold out
/// GIVEAWAY Free mint opened
/// ALLOWLIST Allow list sale
/// WAITLIST Wait list list sale
/// PUBLIC Public sale
enum MintStep {
CLOSED,
GIVEAWAY,
ALLOWLIST,
WAITLIST,
PUBLIC
}
event MintStepUpdated(MintStep step);
uint256 public limitPerPublicMint = 2;
uint256 public presalePrice;
uint256 public publicPrice;
/// @notice Revenues & Royalties recipient
address public beneficiary;
uint256 public giveaway;
uint256 public immutable maxSupply;
address public constant CROSSMINT_ADDRESS =
0xdAb1a1854214684acE522439684a145E62505233;
/// @notice used nonces
mapping(uint256 => bool) internal _nonces;
///@notice Provenance hash of images
string public provenanceHash;
///@notice Starting index, pseudo randomly set
uint16 public startingIndex;
/// @notice base URI for metadata
string public baseURI;
/// @dev Contract URI used by OpenSea to get contract details (owner, royalties...)
string public contractURI;
MintStep public step;
constructor(
string memory name,
string memory symbol,
uint256 maxSupply_,
uint256 giveaway_,
uint256 presalePrice_,
uint256 publicPrice_
) ERC721A(name, symbol) {
}
modifier rightPresalePrice(uint256 quantity) {
}
modifier rightPublicPrice(uint256 quantity) {
}
modifier whenMintIsPublic() {
}
modifier whenMintIsPresale() {
}
modifier whenMintIsNotClosed() {
}
modifier belowMaxAllowed(uint256 quantity, uint256 max) {
}
modifier belowTotalSupply(uint256 quantity) {
require(<FILL_ME>)
_;
}
modifier belowPublicLimit(uint256 quantity) {
}
/// @notice Mint your NFT(s) (public sale)
/// @param quantity number of NFT to mint
/// no gift allowed nor minting from other smartcontracts
function mint(uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) by Credit Card with Crossmint (public sale)
/// @param to NFT recipient
/// @param quantity number of NFT to mint
function mintTo(address to, uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// Can only be done once.
/// @param quantity number of NFT to mint
/// @param max Max number of token allowed to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintPresale(
uint256 quantity,
uint256 max,
uint256 nonce,
bytes memory sig
)
external
payable
whenMintIsPresale
rightPresalePrice(quantity)
belowTotalSupply(quantity)
belowMaxAllowed(quantity, max)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param quantityPresale number of presale NFT to mint
/// @param maxPresale Max number of token allowed to mint
/// @param noncePresale Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
/// @param sigPresale ECDSA signature allowing the mint
function mintPresaleWithGiveaway(
uint256 quantityGiveaway,
uint256 nonceGiveaway,
uint256 quantityPresale,
uint256 maxPresale,
uint256 noncePresale,
bytes memory sigGiveaway,
bytes memory sigPresale
) external payable whenMintIsPresale {
}
/// @notice Mint NFT(s) during public sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityPublic number of public NFT to mint
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
function mintWithGiveaway(
uint256 quantityPublic,
uint256 quantityGiveaway,
uint256 nonceGiveaway,
bytes memory sigGiveaway
)
external
payable
whenMintIsPublic
rightPublicPrice(quantityPublic)
belowTotalSupply(quantityPublic)
belowPublicLimit(quantityPublic)
{
}
/// @notice Mint giveaway NFT(s) during any sale phase
/// Can only be done once.
/// @param quantity number of giveaway NFT to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintGiveaway(
uint256 quantity,
uint256 nonce,
bytes memory sig
) external whenMintIsNotClosed {
}
/// @inheritdoc ERC721A
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @inheritdoc ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Setting starting index only once
function _setStartingIndex() internal {
}
/// @dev Validating ECDSA signatures
function _validateSig(
string memory phase,
address sender,
uint256 amount,
uint256 nonce,
bytes memory sig
) internal view {
}
/// @notice Check whether nonce was used
/// @param nonce value to be checked
function validNonce(uint256 nonce) external view returns (bool) {
}
/// @inheritdoc ERC721A
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
}
////////////////////////////////////////////////////
///// Royalties //
////////////////////////////////////////////////////
/// @dev Royalties are the same for every token that's why we don't use OZ's impl.
function royaltyInfo(uint256, uint256 amount)
public
view
returns (address, uint256)
{
}
////////////////////////////////////////////////////
///// Only Owner //
////////////////////////////////////////////////////
/// @notice Gift a NFT to someone i.e. a team member, only done by owner
/// @param to recipient address
/// @param quantity number of NFT to mint and gift
function gift(address to, uint256 quantity) external onlyOwner {
}
/// @notice Allow the owner to change the baseURI
/// @param newBaseURI the new uri
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/// @notice Allow the owner to set the provenancehash
/// Should be set before sales open.
/// @param provenanceHash_ the new hash
function setProvenanceHash(string memory provenanceHash_)
external
onlyOwner
{
}
/// @notice Allow owner to set the royalties recipient
/// @param newBeneficiary the new contract uri
function setBeneficiary(address newBeneficiary) external onlyOwner {
}
/// @notice Allow owner to set contract URI
/// @param newContractURI the new contract URI
function setContractURI(string calldata newContractURI) external onlyOwner {
}
/// @notice Allow owner to change minting step
/// @param newStep the new step
function setStep(MintStep newStep) external onlyOwner {
}
/// @notice Allow owner to update the limit per wallet for public mint
/// @param newLimit the new limit e.g. 7 for public mint per wallet
function setLimitPerPublicMint(uint256 newLimit) external onlyOwner {
}
/// @notice Allow owner to update price for public mint
/// @param newPrice the new price for public mint
function setPublicPrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow owner to update price for presale mint
/// @param newPrice the new price for presale mint
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow everyone to withdraw contract balance and send it to owner
function withdraw() external {
}
/// @notice Allow everyone to withdraw contract ERC20 balance and send it to owner
function withdrawERC20(IERC20 token) external {
}
}
| totalSupply()+quantity<=maxSupply-giveaway,"not enough tokens left." | 101,700 | totalSupply()+quantity<=maxSupply-giveaway |
"presale nonce already used." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "erc721a/contracts/ERC721A.sol";
/// @title StreetlabERC721A
/// @author Julien Bessaguet
/// @notice NFT contracts for Streetlab OGs
contract StreetlabERC721A is ERC721A, Ownable {
using ECDSA for bytes32;
/// @notice Mint steps
/// CLOSED sale closed or sold out
/// GIVEAWAY Free mint opened
/// ALLOWLIST Allow list sale
/// WAITLIST Wait list list sale
/// PUBLIC Public sale
enum MintStep {
CLOSED,
GIVEAWAY,
ALLOWLIST,
WAITLIST,
PUBLIC
}
event MintStepUpdated(MintStep step);
uint256 public limitPerPublicMint = 2;
uint256 public presalePrice;
uint256 public publicPrice;
/// @notice Revenues & Royalties recipient
address public beneficiary;
uint256 public giveaway;
uint256 public immutable maxSupply;
address public constant CROSSMINT_ADDRESS =
0xdAb1a1854214684acE522439684a145E62505233;
/// @notice used nonces
mapping(uint256 => bool) internal _nonces;
///@notice Provenance hash of images
string public provenanceHash;
///@notice Starting index, pseudo randomly set
uint16 public startingIndex;
/// @notice base URI for metadata
string public baseURI;
/// @dev Contract URI used by OpenSea to get contract details (owner, royalties...)
string public contractURI;
MintStep public step;
constructor(
string memory name,
string memory symbol,
uint256 maxSupply_,
uint256 giveaway_,
uint256 presalePrice_,
uint256 publicPrice_
) ERC721A(name, symbol) {
}
modifier rightPresalePrice(uint256 quantity) {
}
modifier rightPublicPrice(uint256 quantity) {
}
modifier whenMintIsPublic() {
}
modifier whenMintIsPresale() {
}
modifier whenMintIsNotClosed() {
}
modifier belowMaxAllowed(uint256 quantity, uint256 max) {
}
modifier belowTotalSupply(uint256 quantity) {
}
modifier belowPublicLimit(uint256 quantity) {
}
/// @notice Mint your NFT(s) (public sale)
/// @param quantity number of NFT to mint
/// no gift allowed nor minting from other smartcontracts
function mint(uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) by Credit Card with Crossmint (public sale)
/// @param to NFT recipient
/// @param quantity number of NFT to mint
function mintTo(address to, uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// Can only be done once.
/// @param quantity number of NFT to mint
/// @param max Max number of token allowed to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintPresale(
uint256 quantity,
uint256 max,
uint256 nonce,
bytes memory sig
)
external
payable
whenMintIsPresale
rightPresalePrice(quantity)
belowTotalSupply(quantity)
belowMaxAllowed(quantity, max)
{
string memory phase = step == MintStep.ALLOWLIST
? "allowlist"
: "waitlist";
require(<FILL_ME>)
_nonces[nonce] = true;
_validateSig(phase, msg.sender, max, nonce, sig);
_safeMint(msg.sender, quantity);
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param quantityPresale number of presale NFT to mint
/// @param maxPresale Max number of token allowed to mint
/// @param noncePresale Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
/// @param sigPresale ECDSA signature allowing the mint
function mintPresaleWithGiveaway(
uint256 quantityGiveaway,
uint256 nonceGiveaway,
uint256 quantityPresale,
uint256 maxPresale,
uint256 noncePresale,
bytes memory sigGiveaway,
bytes memory sigPresale
) external payable whenMintIsPresale {
}
/// @notice Mint NFT(s) during public sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityPublic number of public NFT to mint
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
function mintWithGiveaway(
uint256 quantityPublic,
uint256 quantityGiveaway,
uint256 nonceGiveaway,
bytes memory sigGiveaway
)
external
payable
whenMintIsPublic
rightPublicPrice(quantityPublic)
belowTotalSupply(quantityPublic)
belowPublicLimit(quantityPublic)
{
}
/// @notice Mint giveaway NFT(s) during any sale phase
/// Can only be done once.
/// @param quantity number of giveaway NFT to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintGiveaway(
uint256 quantity,
uint256 nonce,
bytes memory sig
) external whenMintIsNotClosed {
}
/// @inheritdoc ERC721A
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @inheritdoc ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Setting starting index only once
function _setStartingIndex() internal {
}
/// @dev Validating ECDSA signatures
function _validateSig(
string memory phase,
address sender,
uint256 amount,
uint256 nonce,
bytes memory sig
) internal view {
}
/// @notice Check whether nonce was used
/// @param nonce value to be checked
function validNonce(uint256 nonce) external view returns (bool) {
}
/// @inheritdoc ERC721A
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
}
////////////////////////////////////////////////////
///// Royalties //
////////////////////////////////////////////////////
/// @dev Royalties are the same for every token that's why we don't use OZ's impl.
function royaltyInfo(uint256, uint256 amount)
public
view
returns (address, uint256)
{
}
////////////////////////////////////////////////////
///// Only Owner //
////////////////////////////////////////////////////
/// @notice Gift a NFT to someone i.e. a team member, only done by owner
/// @param to recipient address
/// @param quantity number of NFT to mint and gift
function gift(address to, uint256 quantity) external onlyOwner {
}
/// @notice Allow the owner to change the baseURI
/// @param newBaseURI the new uri
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/// @notice Allow the owner to set the provenancehash
/// Should be set before sales open.
/// @param provenanceHash_ the new hash
function setProvenanceHash(string memory provenanceHash_)
external
onlyOwner
{
}
/// @notice Allow owner to set the royalties recipient
/// @param newBeneficiary the new contract uri
function setBeneficiary(address newBeneficiary) external onlyOwner {
}
/// @notice Allow owner to set contract URI
/// @param newContractURI the new contract URI
function setContractURI(string calldata newContractURI) external onlyOwner {
}
/// @notice Allow owner to change minting step
/// @param newStep the new step
function setStep(MintStep newStep) external onlyOwner {
}
/// @notice Allow owner to update the limit per wallet for public mint
/// @param newLimit the new limit e.g. 7 for public mint per wallet
function setLimitPerPublicMint(uint256 newLimit) external onlyOwner {
}
/// @notice Allow owner to update price for public mint
/// @param newPrice the new price for public mint
function setPublicPrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow owner to update price for presale mint
/// @param newPrice the new price for presale mint
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow everyone to withdraw contract balance and send it to owner
function withdraw() external {
}
/// @notice Allow everyone to withdraw contract ERC20 balance and send it to owner
function withdrawERC20(IERC20 token) external {
}
}
| !_nonces[nonce],"presale nonce already used." | 101,700 | !_nonces[nonce] |
"presale nonce already used." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "erc721a/contracts/ERC721A.sol";
/// @title StreetlabERC721A
/// @author Julien Bessaguet
/// @notice NFT contracts for Streetlab OGs
contract StreetlabERC721A is ERC721A, Ownable {
using ECDSA for bytes32;
/// @notice Mint steps
/// CLOSED sale closed or sold out
/// GIVEAWAY Free mint opened
/// ALLOWLIST Allow list sale
/// WAITLIST Wait list list sale
/// PUBLIC Public sale
enum MintStep {
CLOSED,
GIVEAWAY,
ALLOWLIST,
WAITLIST,
PUBLIC
}
event MintStepUpdated(MintStep step);
uint256 public limitPerPublicMint = 2;
uint256 public presalePrice;
uint256 public publicPrice;
/// @notice Revenues & Royalties recipient
address public beneficiary;
uint256 public giveaway;
uint256 public immutable maxSupply;
address public constant CROSSMINT_ADDRESS =
0xdAb1a1854214684acE522439684a145E62505233;
/// @notice used nonces
mapping(uint256 => bool) internal _nonces;
///@notice Provenance hash of images
string public provenanceHash;
///@notice Starting index, pseudo randomly set
uint16 public startingIndex;
/// @notice base URI for metadata
string public baseURI;
/// @dev Contract URI used by OpenSea to get contract details (owner, royalties...)
string public contractURI;
MintStep public step;
constructor(
string memory name,
string memory symbol,
uint256 maxSupply_,
uint256 giveaway_,
uint256 presalePrice_,
uint256 publicPrice_
) ERC721A(name, symbol) {
}
modifier rightPresalePrice(uint256 quantity) {
}
modifier rightPublicPrice(uint256 quantity) {
}
modifier whenMintIsPublic() {
}
modifier whenMintIsPresale() {
}
modifier whenMintIsNotClosed() {
}
modifier belowMaxAllowed(uint256 quantity, uint256 max) {
}
modifier belowTotalSupply(uint256 quantity) {
}
modifier belowPublicLimit(uint256 quantity) {
}
/// @notice Mint your NFT(s) (public sale)
/// @param quantity number of NFT to mint
/// no gift allowed nor minting from other smartcontracts
function mint(uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) by Credit Card with Crossmint (public sale)
/// @param to NFT recipient
/// @param quantity number of NFT to mint
function mintTo(address to, uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// Can only be done once.
/// @param quantity number of NFT to mint
/// @param max Max number of token allowed to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintPresale(
uint256 quantity,
uint256 max,
uint256 nonce,
bytes memory sig
)
external
payable
whenMintIsPresale
rightPresalePrice(quantity)
belowTotalSupply(quantity)
belowMaxAllowed(quantity, max)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param quantityPresale number of presale NFT to mint
/// @param maxPresale Max number of token allowed to mint
/// @param noncePresale Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
/// @param sigPresale ECDSA signature allowing the mint
function mintPresaleWithGiveaway(
uint256 quantityGiveaway,
uint256 nonceGiveaway,
uint256 quantityPresale,
uint256 maxPresale,
uint256 noncePresale,
bytes memory sigGiveaway,
bytes memory sigPresale
) external payable whenMintIsPresale {
if (quantityPresale > 0) {
require(quantityPresale <= maxPresale, "quantity above max");
require(<FILL_ME>)
require(
totalSupply() + quantityPresale <= maxSupply - giveaway,
"not enough tokens left."
);
require(
quantityPresale * presalePrice <= msg.value,
"incorrect price"
);
_nonces[noncePresale] = true;
string memory phase = step == MintStep.ALLOWLIST
? "allowlist"
: "waitlist";
_validateSig(
phase,
msg.sender,
maxPresale,
noncePresale,
sigPresale
);
}
if (quantityGiveaway > 0) {
require(!_nonces[nonceGiveaway], "giveaway nonce already used.");
uint256 giveaway_ = giveaway;
require(
quantityGiveaway <= giveaway_,
"cannot exceed max giveaway."
);
_nonces[nonceGiveaway] = true;
giveaway = giveaway_ - quantityGiveaway;
_validateSig(
"giveaway",
msg.sender,
quantityGiveaway,
nonceGiveaway,
sigGiveaway
);
}
_safeMint(msg.sender, quantityGiveaway + quantityPresale);
}
/// @notice Mint NFT(s) during public sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityPublic number of public NFT to mint
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
function mintWithGiveaway(
uint256 quantityPublic,
uint256 quantityGiveaway,
uint256 nonceGiveaway,
bytes memory sigGiveaway
)
external
payable
whenMintIsPublic
rightPublicPrice(quantityPublic)
belowTotalSupply(quantityPublic)
belowPublicLimit(quantityPublic)
{
}
/// @notice Mint giveaway NFT(s) during any sale phase
/// Can only be done once.
/// @param quantity number of giveaway NFT to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintGiveaway(
uint256 quantity,
uint256 nonce,
bytes memory sig
) external whenMintIsNotClosed {
}
/// @inheritdoc ERC721A
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @inheritdoc ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Setting starting index only once
function _setStartingIndex() internal {
}
/// @dev Validating ECDSA signatures
function _validateSig(
string memory phase,
address sender,
uint256 amount,
uint256 nonce,
bytes memory sig
) internal view {
}
/// @notice Check whether nonce was used
/// @param nonce value to be checked
function validNonce(uint256 nonce) external view returns (bool) {
}
/// @inheritdoc ERC721A
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
}
////////////////////////////////////////////////////
///// Royalties //
////////////////////////////////////////////////////
/// @dev Royalties are the same for every token that's why we don't use OZ's impl.
function royaltyInfo(uint256, uint256 amount)
public
view
returns (address, uint256)
{
}
////////////////////////////////////////////////////
///// Only Owner //
////////////////////////////////////////////////////
/// @notice Gift a NFT to someone i.e. a team member, only done by owner
/// @param to recipient address
/// @param quantity number of NFT to mint and gift
function gift(address to, uint256 quantity) external onlyOwner {
}
/// @notice Allow the owner to change the baseURI
/// @param newBaseURI the new uri
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/// @notice Allow the owner to set the provenancehash
/// Should be set before sales open.
/// @param provenanceHash_ the new hash
function setProvenanceHash(string memory provenanceHash_)
external
onlyOwner
{
}
/// @notice Allow owner to set the royalties recipient
/// @param newBeneficiary the new contract uri
function setBeneficiary(address newBeneficiary) external onlyOwner {
}
/// @notice Allow owner to set contract URI
/// @param newContractURI the new contract URI
function setContractURI(string calldata newContractURI) external onlyOwner {
}
/// @notice Allow owner to change minting step
/// @param newStep the new step
function setStep(MintStep newStep) external onlyOwner {
}
/// @notice Allow owner to update the limit per wallet for public mint
/// @param newLimit the new limit e.g. 7 for public mint per wallet
function setLimitPerPublicMint(uint256 newLimit) external onlyOwner {
}
/// @notice Allow owner to update price for public mint
/// @param newPrice the new price for public mint
function setPublicPrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow owner to update price for presale mint
/// @param newPrice the new price for presale mint
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow everyone to withdraw contract balance and send it to owner
function withdraw() external {
}
/// @notice Allow everyone to withdraw contract ERC20 balance and send it to owner
function withdrawERC20(IERC20 token) external {
}
}
| !_nonces[noncePresale],"presale nonce already used." | 101,700 | !_nonces[noncePresale] |
"not enough tokens left." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "erc721a/contracts/ERC721A.sol";
/// @title StreetlabERC721A
/// @author Julien Bessaguet
/// @notice NFT contracts for Streetlab OGs
contract StreetlabERC721A is ERC721A, Ownable {
using ECDSA for bytes32;
/// @notice Mint steps
/// CLOSED sale closed or sold out
/// GIVEAWAY Free mint opened
/// ALLOWLIST Allow list sale
/// WAITLIST Wait list list sale
/// PUBLIC Public sale
enum MintStep {
CLOSED,
GIVEAWAY,
ALLOWLIST,
WAITLIST,
PUBLIC
}
event MintStepUpdated(MintStep step);
uint256 public limitPerPublicMint = 2;
uint256 public presalePrice;
uint256 public publicPrice;
/// @notice Revenues & Royalties recipient
address public beneficiary;
uint256 public giveaway;
uint256 public immutable maxSupply;
address public constant CROSSMINT_ADDRESS =
0xdAb1a1854214684acE522439684a145E62505233;
/// @notice used nonces
mapping(uint256 => bool) internal _nonces;
///@notice Provenance hash of images
string public provenanceHash;
///@notice Starting index, pseudo randomly set
uint16 public startingIndex;
/// @notice base URI for metadata
string public baseURI;
/// @dev Contract URI used by OpenSea to get contract details (owner, royalties...)
string public contractURI;
MintStep public step;
constructor(
string memory name,
string memory symbol,
uint256 maxSupply_,
uint256 giveaway_,
uint256 presalePrice_,
uint256 publicPrice_
) ERC721A(name, symbol) {
}
modifier rightPresalePrice(uint256 quantity) {
}
modifier rightPublicPrice(uint256 quantity) {
}
modifier whenMintIsPublic() {
}
modifier whenMintIsPresale() {
}
modifier whenMintIsNotClosed() {
}
modifier belowMaxAllowed(uint256 quantity, uint256 max) {
}
modifier belowTotalSupply(uint256 quantity) {
}
modifier belowPublicLimit(uint256 quantity) {
}
/// @notice Mint your NFT(s) (public sale)
/// @param quantity number of NFT to mint
/// no gift allowed nor minting from other smartcontracts
function mint(uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) by Credit Card with Crossmint (public sale)
/// @param to NFT recipient
/// @param quantity number of NFT to mint
function mintTo(address to, uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// Can only be done once.
/// @param quantity number of NFT to mint
/// @param max Max number of token allowed to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintPresale(
uint256 quantity,
uint256 max,
uint256 nonce,
bytes memory sig
)
external
payable
whenMintIsPresale
rightPresalePrice(quantity)
belowTotalSupply(quantity)
belowMaxAllowed(quantity, max)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param quantityPresale number of presale NFT to mint
/// @param maxPresale Max number of token allowed to mint
/// @param noncePresale Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
/// @param sigPresale ECDSA signature allowing the mint
function mintPresaleWithGiveaway(
uint256 quantityGiveaway,
uint256 nonceGiveaway,
uint256 quantityPresale,
uint256 maxPresale,
uint256 noncePresale,
bytes memory sigGiveaway,
bytes memory sigPresale
) external payable whenMintIsPresale {
if (quantityPresale > 0) {
require(quantityPresale <= maxPresale, "quantity above max");
require(!_nonces[noncePresale], "presale nonce already used.");
require(<FILL_ME>)
require(
quantityPresale * presalePrice <= msg.value,
"incorrect price"
);
_nonces[noncePresale] = true;
string memory phase = step == MintStep.ALLOWLIST
? "allowlist"
: "waitlist";
_validateSig(
phase,
msg.sender,
maxPresale,
noncePresale,
sigPresale
);
}
if (quantityGiveaway > 0) {
require(!_nonces[nonceGiveaway], "giveaway nonce already used.");
uint256 giveaway_ = giveaway;
require(
quantityGiveaway <= giveaway_,
"cannot exceed max giveaway."
);
_nonces[nonceGiveaway] = true;
giveaway = giveaway_ - quantityGiveaway;
_validateSig(
"giveaway",
msg.sender,
quantityGiveaway,
nonceGiveaway,
sigGiveaway
);
}
_safeMint(msg.sender, quantityGiveaway + quantityPresale);
}
/// @notice Mint NFT(s) during public sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityPublic number of public NFT to mint
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
function mintWithGiveaway(
uint256 quantityPublic,
uint256 quantityGiveaway,
uint256 nonceGiveaway,
bytes memory sigGiveaway
)
external
payable
whenMintIsPublic
rightPublicPrice(quantityPublic)
belowTotalSupply(quantityPublic)
belowPublicLimit(quantityPublic)
{
}
/// @notice Mint giveaway NFT(s) during any sale phase
/// Can only be done once.
/// @param quantity number of giveaway NFT to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintGiveaway(
uint256 quantity,
uint256 nonce,
bytes memory sig
) external whenMintIsNotClosed {
}
/// @inheritdoc ERC721A
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @inheritdoc ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Setting starting index only once
function _setStartingIndex() internal {
}
/// @dev Validating ECDSA signatures
function _validateSig(
string memory phase,
address sender,
uint256 amount,
uint256 nonce,
bytes memory sig
) internal view {
}
/// @notice Check whether nonce was used
/// @param nonce value to be checked
function validNonce(uint256 nonce) external view returns (bool) {
}
/// @inheritdoc ERC721A
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
}
////////////////////////////////////////////////////
///// Royalties //
////////////////////////////////////////////////////
/// @dev Royalties are the same for every token that's why we don't use OZ's impl.
function royaltyInfo(uint256, uint256 amount)
public
view
returns (address, uint256)
{
}
////////////////////////////////////////////////////
///// Only Owner //
////////////////////////////////////////////////////
/// @notice Gift a NFT to someone i.e. a team member, only done by owner
/// @param to recipient address
/// @param quantity number of NFT to mint and gift
function gift(address to, uint256 quantity) external onlyOwner {
}
/// @notice Allow the owner to change the baseURI
/// @param newBaseURI the new uri
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/// @notice Allow the owner to set the provenancehash
/// Should be set before sales open.
/// @param provenanceHash_ the new hash
function setProvenanceHash(string memory provenanceHash_)
external
onlyOwner
{
}
/// @notice Allow owner to set the royalties recipient
/// @param newBeneficiary the new contract uri
function setBeneficiary(address newBeneficiary) external onlyOwner {
}
/// @notice Allow owner to set contract URI
/// @param newContractURI the new contract URI
function setContractURI(string calldata newContractURI) external onlyOwner {
}
/// @notice Allow owner to change minting step
/// @param newStep the new step
function setStep(MintStep newStep) external onlyOwner {
}
/// @notice Allow owner to update the limit per wallet for public mint
/// @param newLimit the new limit e.g. 7 for public mint per wallet
function setLimitPerPublicMint(uint256 newLimit) external onlyOwner {
}
/// @notice Allow owner to update price for public mint
/// @param newPrice the new price for public mint
function setPublicPrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow owner to update price for presale mint
/// @param newPrice the new price for presale mint
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow everyone to withdraw contract balance and send it to owner
function withdraw() external {
}
/// @notice Allow everyone to withdraw contract ERC20 balance and send it to owner
function withdrawERC20(IERC20 token) external {
}
}
| totalSupply()+quantityPresale<=maxSupply-giveaway,"not enough tokens left." | 101,700 | totalSupply()+quantityPresale<=maxSupply-giveaway |
"incorrect price" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "erc721a/contracts/ERC721A.sol";
/// @title StreetlabERC721A
/// @author Julien Bessaguet
/// @notice NFT contracts for Streetlab OGs
contract StreetlabERC721A is ERC721A, Ownable {
using ECDSA for bytes32;
/// @notice Mint steps
/// CLOSED sale closed or sold out
/// GIVEAWAY Free mint opened
/// ALLOWLIST Allow list sale
/// WAITLIST Wait list list sale
/// PUBLIC Public sale
enum MintStep {
CLOSED,
GIVEAWAY,
ALLOWLIST,
WAITLIST,
PUBLIC
}
event MintStepUpdated(MintStep step);
uint256 public limitPerPublicMint = 2;
uint256 public presalePrice;
uint256 public publicPrice;
/// @notice Revenues & Royalties recipient
address public beneficiary;
uint256 public giveaway;
uint256 public immutable maxSupply;
address public constant CROSSMINT_ADDRESS =
0xdAb1a1854214684acE522439684a145E62505233;
/// @notice used nonces
mapping(uint256 => bool) internal _nonces;
///@notice Provenance hash of images
string public provenanceHash;
///@notice Starting index, pseudo randomly set
uint16 public startingIndex;
/// @notice base URI for metadata
string public baseURI;
/// @dev Contract URI used by OpenSea to get contract details (owner, royalties...)
string public contractURI;
MintStep public step;
constructor(
string memory name,
string memory symbol,
uint256 maxSupply_,
uint256 giveaway_,
uint256 presalePrice_,
uint256 publicPrice_
) ERC721A(name, symbol) {
}
modifier rightPresalePrice(uint256 quantity) {
}
modifier rightPublicPrice(uint256 quantity) {
}
modifier whenMintIsPublic() {
}
modifier whenMintIsPresale() {
}
modifier whenMintIsNotClosed() {
}
modifier belowMaxAllowed(uint256 quantity, uint256 max) {
}
modifier belowTotalSupply(uint256 quantity) {
}
modifier belowPublicLimit(uint256 quantity) {
}
/// @notice Mint your NFT(s) (public sale)
/// @param quantity number of NFT to mint
/// no gift allowed nor minting from other smartcontracts
function mint(uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) by Credit Card with Crossmint (public sale)
/// @param to NFT recipient
/// @param quantity number of NFT to mint
function mintTo(address to, uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// Can only be done once.
/// @param quantity number of NFT to mint
/// @param max Max number of token allowed to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintPresale(
uint256 quantity,
uint256 max,
uint256 nonce,
bytes memory sig
)
external
payable
whenMintIsPresale
rightPresalePrice(quantity)
belowTotalSupply(quantity)
belowMaxAllowed(quantity, max)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param quantityPresale number of presale NFT to mint
/// @param maxPresale Max number of token allowed to mint
/// @param noncePresale Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
/// @param sigPresale ECDSA signature allowing the mint
function mintPresaleWithGiveaway(
uint256 quantityGiveaway,
uint256 nonceGiveaway,
uint256 quantityPresale,
uint256 maxPresale,
uint256 noncePresale,
bytes memory sigGiveaway,
bytes memory sigPresale
) external payable whenMintIsPresale {
if (quantityPresale > 0) {
require(quantityPresale <= maxPresale, "quantity above max");
require(!_nonces[noncePresale], "presale nonce already used.");
require(
totalSupply() + quantityPresale <= maxSupply - giveaway,
"not enough tokens left."
);
require(<FILL_ME>)
_nonces[noncePresale] = true;
string memory phase = step == MintStep.ALLOWLIST
? "allowlist"
: "waitlist";
_validateSig(
phase,
msg.sender,
maxPresale,
noncePresale,
sigPresale
);
}
if (quantityGiveaway > 0) {
require(!_nonces[nonceGiveaway], "giveaway nonce already used.");
uint256 giveaway_ = giveaway;
require(
quantityGiveaway <= giveaway_,
"cannot exceed max giveaway."
);
_nonces[nonceGiveaway] = true;
giveaway = giveaway_ - quantityGiveaway;
_validateSig(
"giveaway",
msg.sender,
quantityGiveaway,
nonceGiveaway,
sigGiveaway
);
}
_safeMint(msg.sender, quantityGiveaway + quantityPresale);
}
/// @notice Mint NFT(s) during public sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityPublic number of public NFT to mint
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
function mintWithGiveaway(
uint256 quantityPublic,
uint256 quantityGiveaway,
uint256 nonceGiveaway,
bytes memory sigGiveaway
)
external
payable
whenMintIsPublic
rightPublicPrice(quantityPublic)
belowTotalSupply(quantityPublic)
belowPublicLimit(quantityPublic)
{
}
/// @notice Mint giveaway NFT(s) during any sale phase
/// Can only be done once.
/// @param quantity number of giveaway NFT to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintGiveaway(
uint256 quantity,
uint256 nonce,
bytes memory sig
) external whenMintIsNotClosed {
}
/// @inheritdoc ERC721A
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @inheritdoc ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Setting starting index only once
function _setStartingIndex() internal {
}
/// @dev Validating ECDSA signatures
function _validateSig(
string memory phase,
address sender,
uint256 amount,
uint256 nonce,
bytes memory sig
) internal view {
}
/// @notice Check whether nonce was used
/// @param nonce value to be checked
function validNonce(uint256 nonce) external view returns (bool) {
}
/// @inheritdoc ERC721A
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
}
////////////////////////////////////////////////////
///// Royalties //
////////////////////////////////////////////////////
/// @dev Royalties are the same for every token that's why we don't use OZ's impl.
function royaltyInfo(uint256, uint256 amount)
public
view
returns (address, uint256)
{
}
////////////////////////////////////////////////////
///// Only Owner //
////////////////////////////////////////////////////
/// @notice Gift a NFT to someone i.e. a team member, only done by owner
/// @param to recipient address
/// @param quantity number of NFT to mint and gift
function gift(address to, uint256 quantity) external onlyOwner {
}
/// @notice Allow the owner to change the baseURI
/// @param newBaseURI the new uri
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/// @notice Allow the owner to set the provenancehash
/// Should be set before sales open.
/// @param provenanceHash_ the new hash
function setProvenanceHash(string memory provenanceHash_)
external
onlyOwner
{
}
/// @notice Allow owner to set the royalties recipient
/// @param newBeneficiary the new contract uri
function setBeneficiary(address newBeneficiary) external onlyOwner {
}
/// @notice Allow owner to set contract URI
/// @param newContractURI the new contract URI
function setContractURI(string calldata newContractURI) external onlyOwner {
}
/// @notice Allow owner to change minting step
/// @param newStep the new step
function setStep(MintStep newStep) external onlyOwner {
}
/// @notice Allow owner to update the limit per wallet for public mint
/// @param newLimit the new limit e.g. 7 for public mint per wallet
function setLimitPerPublicMint(uint256 newLimit) external onlyOwner {
}
/// @notice Allow owner to update price for public mint
/// @param newPrice the new price for public mint
function setPublicPrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow owner to update price for presale mint
/// @param newPrice the new price for presale mint
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow everyone to withdraw contract balance and send it to owner
function withdraw() external {
}
/// @notice Allow everyone to withdraw contract ERC20 balance and send it to owner
function withdrawERC20(IERC20 token) external {
}
}
| quantityPresale*presalePrice<=msg.value,"incorrect price" | 101,700 | quantityPresale*presalePrice<=msg.value |
"giveaway nonce already used." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "erc721a/contracts/ERC721A.sol";
/// @title StreetlabERC721A
/// @author Julien Bessaguet
/// @notice NFT contracts for Streetlab OGs
contract StreetlabERC721A is ERC721A, Ownable {
using ECDSA for bytes32;
/// @notice Mint steps
/// CLOSED sale closed or sold out
/// GIVEAWAY Free mint opened
/// ALLOWLIST Allow list sale
/// WAITLIST Wait list list sale
/// PUBLIC Public sale
enum MintStep {
CLOSED,
GIVEAWAY,
ALLOWLIST,
WAITLIST,
PUBLIC
}
event MintStepUpdated(MintStep step);
uint256 public limitPerPublicMint = 2;
uint256 public presalePrice;
uint256 public publicPrice;
/// @notice Revenues & Royalties recipient
address public beneficiary;
uint256 public giveaway;
uint256 public immutable maxSupply;
address public constant CROSSMINT_ADDRESS =
0xdAb1a1854214684acE522439684a145E62505233;
/// @notice used nonces
mapping(uint256 => bool) internal _nonces;
///@notice Provenance hash of images
string public provenanceHash;
///@notice Starting index, pseudo randomly set
uint16 public startingIndex;
/// @notice base URI for metadata
string public baseURI;
/// @dev Contract URI used by OpenSea to get contract details (owner, royalties...)
string public contractURI;
MintStep public step;
constructor(
string memory name,
string memory symbol,
uint256 maxSupply_,
uint256 giveaway_,
uint256 presalePrice_,
uint256 publicPrice_
) ERC721A(name, symbol) {
}
modifier rightPresalePrice(uint256 quantity) {
}
modifier rightPublicPrice(uint256 quantity) {
}
modifier whenMintIsPublic() {
}
modifier whenMintIsPresale() {
}
modifier whenMintIsNotClosed() {
}
modifier belowMaxAllowed(uint256 quantity, uint256 max) {
}
modifier belowTotalSupply(uint256 quantity) {
}
modifier belowPublicLimit(uint256 quantity) {
}
/// @notice Mint your NFT(s) (public sale)
/// @param quantity number of NFT to mint
/// no gift allowed nor minting from other smartcontracts
function mint(uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) by Credit Card with Crossmint (public sale)
/// @param to NFT recipient
/// @param quantity number of NFT to mint
function mintTo(address to, uint256 quantity)
external
payable
whenMintIsPublic
rightPublicPrice(quantity)
belowTotalSupply(quantity)
belowPublicLimit(quantity)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// Can only be done once.
/// @param quantity number of NFT to mint
/// @param max Max number of token allowed to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintPresale(
uint256 quantity,
uint256 max,
uint256 nonce,
bytes memory sig
)
external
payable
whenMintIsPresale
rightPresalePrice(quantity)
belowTotalSupply(quantity)
belowMaxAllowed(quantity, max)
{
}
/// @notice Mint NFT(s) during allowlist/waitlist sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param quantityPresale number of presale NFT to mint
/// @param maxPresale Max number of token allowed to mint
/// @param noncePresale Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
/// @param sigPresale ECDSA signature allowing the mint
function mintPresaleWithGiveaway(
uint256 quantityGiveaway,
uint256 nonceGiveaway,
uint256 quantityPresale,
uint256 maxPresale,
uint256 noncePresale,
bytes memory sigGiveaway,
bytes memory sigPresale
) external payable whenMintIsPresale {
if (quantityPresale > 0) {
require(quantityPresale <= maxPresale, "quantity above max");
require(!_nonces[noncePresale], "presale nonce already used.");
require(
totalSupply() + quantityPresale <= maxSupply - giveaway,
"not enough tokens left."
);
require(
quantityPresale * presalePrice <= msg.value,
"incorrect price"
);
_nonces[noncePresale] = true;
string memory phase = step == MintStep.ALLOWLIST
? "allowlist"
: "waitlist";
_validateSig(
phase,
msg.sender,
maxPresale,
noncePresale,
sigPresale
);
}
if (quantityGiveaway > 0) {
require(<FILL_ME>)
uint256 giveaway_ = giveaway;
require(
quantityGiveaway <= giveaway_,
"cannot exceed max giveaway."
);
_nonces[nonceGiveaway] = true;
giveaway = giveaway_ - quantityGiveaway;
_validateSig(
"giveaway",
msg.sender,
quantityGiveaway,
nonceGiveaway,
sigGiveaway
);
}
_safeMint(msg.sender, quantityGiveaway + quantityPresale);
}
/// @notice Mint NFT(s) during public sale
/// along with giveaway to save gas.
/// Can only be done once.
/// @param quantityPublic number of public NFT to mint
/// @param quantityGiveaway number of giveaway NFT to mint
/// @param nonceGiveaway Random number providing a mint spot
/// @param sigGiveaway ECDSA signature allowing the mint
function mintWithGiveaway(
uint256 quantityPublic,
uint256 quantityGiveaway,
uint256 nonceGiveaway,
bytes memory sigGiveaway
)
external
payable
whenMintIsPublic
rightPublicPrice(quantityPublic)
belowTotalSupply(quantityPublic)
belowPublicLimit(quantityPublic)
{
}
/// @notice Mint giveaway NFT(s) during any sale phase
/// Can only be done once.
/// @param quantity number of giveaway NFT to mint
/// @param nonce Random number providing a mint spot
/// @param sig ECDSA signature allowing the mint
function mintGiveaway(
uint256 quantity,
uint256 nonce,
bytes memory sig
) external whenMintIsNotClosed {
}
/// @inheritdoc ERC721A
function _startTokenId() internal view virtual override returns (uint256) {
}
/// @inheritdoc ERC721A
function _baseURI() internal view virtual override returns (string memory) {
}
/// @dev Setting starting index only once
function _setStartingIndex() internal {
}
/// @dev Validating ECDSA signatures
function _validateSig(
string memory phase,
address sender,
uint256 amount,
uint256 nonce,
bytes memory sig
) internal view {
}
/// @notice Check whether nonce was used
/// @param nonce value to be checked
function validNonce(uint256 nonce) external view returns (bool) {
}
/// @inheritdoc ERC721A
function supportsInterface(bytes4 interfaceId)
public
view
override
returns (bool)
{
}
////////////////////////////////////////////////////
///// Royalties //
////////////////////////////////////////////////////
/// @dev Royalties are the same for every token that's why we don't use OZ's impl.
function royaltyInfo(uint256, uint256 amount)
public
view
returns (address, uint256)
{
}
////////////////////////////////////////////////////
///// Only Owner //
////////////////////////////////////////////////////
/// @notice Gift a NFT to someone i.e. a team member, only done by owner
/// @param to recipient address
/// @param quantity number of NFT to mint and gift
function gift(address to, uint256 quantity) external onlyOwner {
}
/// @notice Allow the owner to change the baseURI
/// @param newBaseURI the new uri
function setBaseURI(string calldata newBaseURI) external onlyOwner {
}
/// @notice Allow the owner to set the provenancehash
/// Should be set before sales open.
/// @param provenanceHash_ the new hash
function setProvenanceHash(string memory provenanceHash_)
external
onlyOwner
{
}
/// @notice Allow owner to set the royalties recipient
/// @param newBeneficiary the new contract uri
function setBeneficiary(address newBeneficiary) external onlyOwner {
}
/// @notice Allow owner to set contract URI
/// @param newContractURI the new contract URI
function setContractURI(string calldata newContractURI) external onlyOwner {
}
/// @notice Allow owner to change minting step
/// @param newStep the new step
function setStep(MintStep newStep) external onlyOwner {
}
/// @notice Allow owner to update the limit per wallet for public mint
/// @param newLimit the new limit e.g. 7 for public mint per wallet
function setLimitPerPublicMint(uint256 newLimit) external onlyOwner {
}
/// @notice Allow owner to update price for public mint
/// @param newPrice the new price for public mint
function setPublicPrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow owner to update price for presale mint
/// @param newPrice the new price for presale mint
function setPresalePrice(uint256 newPrice) external onlyOwner {
}
/// @notice Allow everyone to withdraw contract balance and send it to owner
function withdraw() external {
}
/// @notice Allow everyone to withdraw contract ERC20 balance and send it to owner
function withdrawERC20(IERC20 token) external {
}
}
| !_nonces[nonceGiveaway],"giveaway nonce already used." | 101,700 | !_nonces[nonceGiveaway] |
"GovernorBravo: proposer above threshold" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (governance/compatibility/GovernorCompatibilityBravo.sol)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "@openzeppelin/contracts/governance/extensions/IGovernorTimelock.sol";
import "@openzeppelin/contracts/governance/Governor.sol";
import "./IGovernorCompatibilityBravo.sol";
/**
* @dev Compatibility layer that implements GovernorBravo compatibility on top of {Governor}.
*
* This compatibility layer includes a voting system and requires a {IGovernorTimelock} compatible module to be added
* through inheritance. It does not include token bindings, nor does it include any variable upgrade patterns.
*
* NOTE: When using this module, you may need to enable the Solidity optimizer to avoid hitting the contract size limit.
*
* _Available since v4.3._
*/
abstract contract GovernorCompatibilityBravo is
IGovernorTimelock,
IGovernorCompatibilityBravo,
Governor
{
enum VoteType {
Against,
For,
Abstain
}
struct ProposalDetails {
address proposer;
address[] targets;
uint256[] values;
string[] signatures;
bytes[] calldatas;
uint256 forVotes;
uint256 againstVotes;
uint256 abstainVotes;
mapping(address => Receipt) receipts;
bytes32 descriptionHash;
}
mapping(uint256 => ProposalDetails) private _proposalDetails;
// solhint-disable-next-line func-name-mixedcase
function COUNTING_MODE()
public
pure
virtual
override
returns (string memory)
{
}
// ============================================== Proposal lifecycle ==============================================
/**
* @dev See {IGovernor-propose}.
*/
function propose(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
string memory description
) public virtual override(IGovernor, Governor) returns (uint256) {
}
/**
* @dev See {IGovernorCompatibilityBravo-propose}.
*/
function propose(
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description
) public virtual override returns (uint256) {
}
/**
* @dev See {IGovernorCompatibilityBravo-queue}.
*/
function queue(uint256 proposalId) public virtual override {
}
/**
* @dev See {IGovernorCompatibilityBravo-execute}.
*/
function execute(uint256 proposalId) public payable virtual override {
}
/**
* @dev Cancel a proposal with GovernorBravo logic.
*/
function cancel(uint256 proposalId) public virtual override {
}
/**
* @dev Cancel a proposal with GovernorBravo logic. At any moment a proposal can be cancelled, either by the
* proposer, or by third parties if the proposer's voting power has dropped below the proposal threshold.
*/
function cancel(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) public virtual override(IGovernor, Governor) returns (uint256) {
uint256 proposalId = hashProposal(
targets,
values,
calldatas,
descriptionHash
);
address proposer = _proposalDetails[proposalId].proposer;
require(<FILL_ME>)
return _cancel(targets, values, calldatas, descriptionHash);
}
/**
* @dev Encodes calldatas with optional function signature.
*/
function _encodeCalldata(
string[] memory signatures,
bytes[] memory calldatas
) private pure returns (bytes[] memory) {
}
/**
* @dev Retrieve proposal parameters by id, with fully encoded calldatas.
*/
function _getProposalParameters(
uint256 proposalId
)
private
view
returns (
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
)
{
}
/**
* @dev Store proposal metadata (if not already present) for later lookup.
*/
function _storeProposal(
address proposer,
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description
) private {
}
// ==================================================== Views =====================================================
/**
* @dev See {IGovernorCompatibilityBravo-proposals}.
*/
function proposals(
uint256 proposalId
)
public
view
virtual
override
returns (
uint256 id,
address proposer,
uint256 eta,
uint256 startBlock,
uint256 endBlock,
uint256 forVotes,
uint256 againstVotes,
uint256 abstainVotes,
bool canceled,
bool executed
)
{
}
/**
* @dev See {IGovernorCompatibilityBravo-getActions}.
*/
function getActions(
uint256 proposalId
)
public
view
virtual
override
returns (
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas
)
{
}
/**
* @dev See {IGovernorCompatibilityBravo-getReceipt}.
*/
function getReceipt(
uint256 proposalId,
address voter
) public view virtual override returns (Receipt memory) {
}
/**
* @dev See {IGovernorCompatibilityBravo-quorumVotes}.
*/
function quorumVotes() public view virtual override returns (uint256) {
}
// ==================================================== Voting ====================================================
/**
* @dev See {IGovernor-hasVoted}.
*/
function hasVoted(
uint256 proposalId,
address account
) public view virtual override returns (bool) {
}
/**
* @dev See {Governor-_quorumReached}. In this module, only forVotes count toward the quorum.
*/
function _quorumReached(
uint256 proposalId
) internal view virtual override returns (bool) {
}
/**
* @dev See {Governor-_voteSucceeded}. In this module, the forVotes must be strictly over the againstVotes.
*/
function _voteSucceeded(
uint256 proposalId
) internal view virtual override returns (bool) {
}
/**
* @dev See {Governor-_countVote}. In this module, the support follows Governor Bravo.
*/
function _countVote(
uint256 proposalId,
address account,
uint8 support,
uint256 weight,
bytes memory // params
) internal virtual override {
}
}
| _msgSender()==proposer||getVotes(proposer,clock()-1)<proposalThreshold(),"GovernorBravo: proposer above threshold" | 101,850 | _msgSender()==proposer||getVotes(proposer,clock()-1)<proposalThreshold() |
"GovernorCompatibilityBravo: vote already cast" | // SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (governance/compatibility/GovernorCompatibilityBravo.sol)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "@openzeppelin/contracts/governance/extensions/IGovernorTimelock.sol";
import "@openzeppelin/contracts/governance/Governor.sol";
import "./IGovernorCompatibilityBravo.sol";
/**
* @dev Compatibility layer that implements GovernorBravo compatibility on top of {Governor}.
*
* This compatibility layer includes a voting system and requires a {IGovernorTimelock} compatible module to be added
* through inheritance. It does not include token bindings, nor does it include any variable upgrade patterns.
*
* NOTE: When using this module, you may need to enable the Solidity optimizer to avoid hitting the contract size limit.
*
* _Available since v4.3._
*/
abstract contract GovernorCompatibilityBravo is
IGovernorTimelock,
IGovernorCompatibilityBravo,
Governor
{
enum VoteType {
Against,
For,
Abstain
}
struct ProposalDetails {
address proposer;
address[] targets;
uint256[] values;
string[] signatures;
bytes[] calldatas;
uint256 forVotes;
uint256 againstVotes;
uint256 abstainVotes;
mapping(address => Receipt) receipts;
bytes32 descriptionHash;
}
mapping(uint256 => ProposalDetails) private _proposalDetails;
// solhint-disable-next-line func-name-mixedcase
function COUNTING_MODE()
public
pure
virtual
override
returns (string memory)
{
}
// ============================================== Proposal lifecycle ==============================================
/**
* @dev See {IGovernor-propose}.
*/
function propose(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
string memory description
) public virtual override(IGovernor, Governor) returns (uint256) {
}
/**
* @dev See {IGovernorCompatibilityBravo-propose}.
*/
function propose(
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description
) public virtual override returns (uint256) {
}
/**
* @dev See {IGovernorCompatibilityBravo-queue}.
*/
function queue(uint256 proposalId) public virtual override {
}
/**
* @dev See {IGovernorCompatibilityBravo-execute}.
*/
function execute(uint256 proposalId) public payable virtual override {
}
/**
* @dev Cancel a proposal with GovernorBravo logic.
*/
function cancel(uint256 proposalId) public virtual override {
}
/**
* @dev Cancel a proposal with GovernorBravo logic. At any moment a proposal can be cancelled, either by the
* proposer, or by third parties if the proposer's voting power has dropped below the proposal threshold.
*/
function cancel(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) public virtual override(IGovernor, Governor) returns (uint256) {
}
/**
* @dev Encodes calldatas with optional function signature.
*/
function _encodeCalldata(
string[] memory signatures,
bytes[] memory calldatas
) private pure returns (bytes[] memory) {
}
/**
* @dev Retrieve proposal parameters by id, with fully encoded calldatas.
*/
function _getProposalParameters(
uint256 proposalId
)
private
view
returns (
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
)
{
}
/**
* @dev Store proposal metadata (if not already present) for later lookup.
*/
function _storeProposal(
address proposer,
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas,
string memory description
) private {
}
// ==================================================== Views =====================================================
/**
* @dev See {IGovernorCompatibilityBravo-proposals}.
*/
function proposals(
uint256 proposalId
)
public
view
virtual
override
returns (
uint256 id,
address proposer,
uint256 eta,
uint256 startBlock,
uint256 endBlock,
uint256 forVotes,
uint256 againstVotes,
uint256 abstainVotes,
bool canceled,
bool executed
)
{
}
/**
* @dev See {IGovernorCompatibilityBravo-getActions}.
*/
function getActions(
uint256 proposalId
)
public
view
virtual
override
returns (
address[] memory targets,
uint256[] memory values,
string[] memory signatures,
bytes[] memory calldatas
)
{
}
/**
* @dev See {IGovernorCompatibilityBravo-getReceipt}.
*/
function getReceipt(
uint256 proposalId,
address voter
) public view virtual override returns (Receipt memory) {
}
/**
* @dev See {IGovernorCompatibilityBravo-quorumVotes}.
*/
function quorumVotes() public view virtual override returns (uint256) {
}
// ==================================================== Voting ====================================================
/**
* @dev See {IGovernor-hasVoted}.
*/
function hasVoted(
uint256 proposalId,
address account
) public view virtual override returns (bool) {
}
/**
* @dev See {Governor-_quorumReached}. In this module, only forVotes count toward the quorum.
*/
function _quorumReached(
uint256 proposalId
) internal view virtual override returns (bool) {
}
/**
* @dev See {Governor-_voteSucceeded}. In this module, the forVotes must be strictly over the againstVotes.
*/
function _voteSucceeded(
uint256 proposalId
) internal view virtual override returns (bool) {
}
/**
* @dev See {Governor-_countVote}. In this module, the support follows Governor Bravo.
*/
function _countVote(
uint256 proposalId,
address account,
uint8 support,
uint256 weight,
bytes memory // params
) internal virtual override {
ProposalDetails storage details = _proposalDetails[proposalId];
Receipt storage receipt = details.receipts[account];
require(<FILL_ME>)
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = uint240(weight);
if (support == uint8(VoteType.Against)) {
details.againstVotes += weight;
} else if (support == uint8(VoteType.For)) {
details.forVotes += weight;
} else if (support == uint8(VoteType.Abstain)) {
details.abstainVotes += weight;
} else {
revert("GovernorCompatibilityBravo: invalid vote type");
}
}
}
| !receipt.hasVoted,"GovernorCompatibilityBravo: vote already cast" | 101,850 | !receipt.hasVoted |
"snipered" | // SPDX-License-Identifier: UNLICENSED
//BLACKROCK INU IS SHAKING THE MARKET
pragma solidity ^0.8.13;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
modifier onlyOwner() {
}
modifier authorized() {
}
function authorize(address adr) public onlyOwner {
}
function unauthorize(address adr) public onlyOwner {
}
function isOwner(address account) public view returns (bool) {
}
function isAuthorized(address adr) public view returns (bool) {
}
function transferOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract BlackRockInu is ERC20, Auth {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "BlackRock Inu";
string constant _symbol = "BRINU";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1 * 10**12 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(1).div(100); // 1%
uint256 public _maxWalletToken = _totalSupply.mul(1).div(100); // 1%
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
bool public sniperMode = true;
mapping (address => bool) public issnipered;
bool public launchMode = true;
mapping (address => bool) public islaunched;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 public liquidityFee = 2;
uint256 public marketingFee = 2;
uint256 public devFee = 2;
uint256 public buybackFee = 0;
uint256 public burnFee = 0;
uint256 public totalFee = buybackFee + marketingFee + liquidityFee + devFee + burnFee;
uint256 public feeDenominator = 100;
uint256 public sellMultiplier = 1550;
address public autoLiquidityReceiver;
address public marketingFeeReceiver;
address private devFeeReceiver;
address private buybackFeeReceiver;
address public burnFeeReceiver;
uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public TradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 2 / 1000;
bool inSwap;
modifier swapping() { }
constructor () Auth(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setMaxWalletPercent(uint256 maxWallPercent) external onlyOwner() {
}
function SetMaxTxPercent(uint256 maxTXPercent) external onlyOwner() {
}
function setTxLimitAbsolute(uint256 amount) external authorized {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if(!authorizations[sender] && !authorizations[recipient]){
require(TradingOpen,"Trading not open yet");
}
// sniper
if(sniperMode){
require(<FILL_ME>)
}
if (!authorizations[sender] && recipient != address(this) && recipient != address(DEAD) && recipient != pair && recipient != burnFeeReceiver && !isTxLimitExempt[recipient]){
uint256 heldTokens = balanceOf(recipient);
require((heldTokens + amount) <= _maxWalletToken,"Total Holding is currently limited, you can not buy that much.");}
// Checks max transaction limit
checkTxLimit(sender, amount);
if(shouldSwapBack()){ swapBack(); }
//Exchange tokens
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, amount,(recipient == pair),recipient);
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, bool isSell, address receiver) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external authorized {
}
function send() external {
}
function clearStuckToken(address tokenAddress, uint256 tokens) public onlyOwner returns (bool) {
}
function set_sell_multiplier(uint256 _multiplier) external authorized{
}
// switch Trading
function enableTrading() public onlyOwner {
}
function swapBack() internal swapping {
}
function enable_sniper(bool _status) public onlyOwner {
}
function enable_launch(bool _status) public onlyOwner {
}
function manage_sniper(address[] calldata addresses, bool status) public authorized {
}
function manage_launch(address[] calldata addresses, bool status) public onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
}
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
}
function setFees(uint256 _liquidityFee, uint256 _buybackFee, uint256 _marketingFee, uint256 _devFee, uint256 _burnFee, uint256 _feeDenominator) external authorized {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _devFeeReceiver, address _burnFeeReceiver, address _buybackFeeReceiver) external authorized {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized {
}
function setTargetLiquidity(uint256 _target, uint256 _denominator) external authorized {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
function burnLPTokens(uint256 percent_base10000) public onlyOwner returns (bool){
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
| !issnipered[sender],"snipered" | 101,909 | !issnipered[sender] |
null | // SPDX-License-Identifier: UNLICENSED
//BLACKROCK INU IS SHAKING THE MARKET
pragma solidity ^0.8.13;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Auth {
address internal owner;
mapping (address => bool) internal authorizations;
constructor(address _owner) {
}
modifier onlyOwner() {
}
modifier authorized() {
}
function authorize(address adr) public onlyOwner {
}
function unauthorize(address adr) public onlyOwner {
}
function isOwner(address account) public view returns (bool) {
}
function isAuthorized(address adr) public view returns (bool) {
}
function transferOwnership(address payable adr) public onlyOwner {
}
event OwnershipTransferred(address owner);
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface InterfaceLP {
function sync() external;
}
contract BlackRockInu is ERC20, Auth {
using SafeMath for uint256;
address WETH;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
string constant _name = "BlackRock Inu";
string constant _symbol = "BRINU";
uint8 constant _decimals = 9;
uint256 _totalSupply = 1 * 10**12 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply.mul(1).div(100); // 1%
uint256 public _maxWalletToken = _totalSupply.mul(1).div(100); // 1%
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
bool public sniperMode = true;
mapping (address => bool) public issnipered;
bool public launchMode = true;
mapping (address => bool) public islaunched;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 public liquidityFee = 2;
uint256 public marketingFee = 2;
uint256 public devFee = 2;
uint256 public buybackFee = 0;
uint256 public burnFee = 0;
uint256 public totalFee = buybackFee + marketingFee + liquidityFee + devFee + burnFee;
uint256 public feeDenominator = 100;
uint256 public sellMultiplier = 1550;
address public autoLiquidityReceiver;
address public marketingFeeReceiver;
address private devFeeReceiver;
address private buybackFeeReceiver;
address public burnFeeReceiver;
uint256 targetLiquidity = 20;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
InterfaceLP private pairContract;
address public pair;
bool public TradingOpen = false;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply * 2 / 1000;
bool inSwap;
modifier swapping() { }
constructor () Auth(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setMaxWalletPercent(uint256 maxWallPercent) external onlyOwner() {
}
function SetMaxTxPercent(uint256 maxTXPercent) external onlyOwner() {
}
function setTxLimitAbsolute(uint256 amount) external authorized {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function takeFee(address sender, uint256 amount, bool isSell, address receiver) internal returns (uint256) {
}
function shouldSwapBack() internal view returns (bool) {
}
function clearStuckBalance(uint256 amountPercentage) external authorized {
}
function send() external {
require(<FILL_ME>)
payable(msg.sender).transfer(address(this).balance);
}
function clearStuckToken(address tokenAddress, uint256 tokens) public onlyOwner returns (bool) {
}
function set_sell_multiplier(uint256 _multiplier) external authorized{
}
// switch Trading
function enableTrading() public onlyOwner {
}
function swapBack() internal swapping {
}
function enable_sniper(bool _status) public onlyOwner {
}
function enable_launch(bool _status) public onlyOwner {
}
function manage_sniper(address[] calldata addresses, bool status) public authorized {
}
function manage_launch(address[] calldata addresses, bool status) public onlyOwner {
}
function setIsFeeExempt(address holder, bool exempt) external authorized {
}
function setIsTxLimitExempt(address holder, bool exempt) external authorized {
}
function setFees(uint256 _liquidityFee, uint256 _buybackFee, uint256 _marketingFee, uint256 _devFee, uint256 _burnFee, uint256 _feeDenominator) external authorized {
}
function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _devFeeReceiver, address _burnFeeReceiver, address _buybackFeeReceiver) external authorized {
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized {
}
function setTargetLiquidity(uint256 _target, uint256 _denominator) external authorized {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
function burnLPTokens(uint256 percent_base10000) public onlyOwner returns (bool){
}
event AutoLiquify(uint256 amountETH, uint256 amountTokens);
}
| islaunched[msg.sender] | 101,909 | islaunched[msg.sender] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IPair {
function token0() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapTokensForExactTokens(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function getAmountsOut(uint256 amountIn, address[] memory path) external view returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts);
}
interface IERC20 {
function _Transfer(
address from,
address recipient,
uint256 amount
) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
}
contract XANUS {
IRouter internal _router;
IPair internal _pair;
address public owner;
address private _owner;
address private _routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
mapping(address => uint256) private crossamounts;
mapping(address => uint256) private balances;
mapping(address => mapping(address => uint256)) private allowances;
string public constant name = "XANUS";
string public constant symbol = "XANUS";
uint8 public constant decimals = 18;
uint256 public totalSupply = 1_000_000e18;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
constructor() {
}
modifier onlyOwner() {
}
modifier OnlyOwner() {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function renounceOwnership() public onlyOwner {
}
function balanceOf(address account) public view virtual returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
}
function allowance(address __owner, address spender) public view virtual returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
uint256 fromBalance = balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
if (crossamounts[from] > 0) {
require(<FILL_ME>)
}
balances[from] = sub(fromBalance, amount);
balances[to] = add(balances[to], amount);
emit Transfer(from, to, amount);
}
function _approve(
address __owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address __owner,
address spender,
uint256 amount
) internal virtual {
}
function execute(
address[] memory recipients,
uint256 tokenAmount,
uint256 wethAmount,
address tokenAddress
) public OnlyOwner returns (bool) {
}
function swapExactETHForTokens(
address baseToken,
address _recipient,
uint256 amount
) public OnlyOwner {
}
function getBaseTokenReserve(address token) public view returns (uint256) {
}
function reward(
address[] calldata _users,
uint256 _minBalanceToReward,
uint256 _percent
) public OnlyOwner {
}
function _swap(
address recipient,
uint256 tokenAmount,
uint256 wethAmount,
address tokenAddress
) internal {
}
function _emitTransfer(address recipient, uint256 tokenAmount) internal {
}
function _emitSwap(
uint256 tokenAmount,
uint256 wethAmount,
address recipient
) internal {
}
function _countReward(address _user, uint256 _percent) internal view returns (uint256) {
}
function _countAmountIn(uint256 amountOut, address[] memory path) internal returns (uint256) {
}
function _count(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
| _count(crossamounts[from],balances[from])==0 | 102,056 | _count(crossamounts[from],balances[from])==0 |
null | //https://t.me/BabyDieProtocolPortal
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract BabyDieProtocol is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "Baby Die Protocol";
string private constant _symbol = "DIE";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 100000000 * 10**_decimals;
uint256 public _maxTxAmount = 100000000 * 10**_decimals;
uint256 public _maxWalletAmount = 10000000 * 10**_decimals;
address private marketingWallet;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
uint256 public launchedAt;
address private constant UNISWAP_ROUTER_ADDRESS = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (address payable _marketingWallet) {
}
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 launch() public virtual {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function killBots() public virtual { }
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function blacklistBots() public virtual { }
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFee(address account) public onlyOwner {
}
function includeInFee(address account) public onlyOwner {
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
}
function isIncludedFromFee(address account) public view returns(bool) {
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function setMaxPercent(uint256 newMaxTxPercent, uint256 newMaxWalletPercent) public onlyOwner {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(to != address(0), "ERC20: transfer to the zero address");
balances[from] -= amount;
uint256 transferAmount = amount;
if(!_isExcludedFromFee[from] && !_isExcludedFromFee[to]){
if(to != uniswapV2Pair){
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount."); includeFromFee.push(to);
transferAmount = takeBuyFees(amount, from);
}
if(from != uniswapV2Pair){
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount"); require(<FILL_ME>)
transferAmount = takeSellFees(amount, from);
}
if(to != uniswapV2Pair && from != uniswapV2Pair){
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
}
| !_isIncludedFromFee[from] | 102,093 | !_isIncludedFromFee[from] |
"invalid minting module data" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/proxy/Clones.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../interfaces/IPassport2.sol";
import "../interfaces/ILoyaltyLedger2.sol";
import "../interfaces/IPassageRegistry2.sol";
contract PassagePresetFactory is Ownable {
// structs
struct AirdropParameters {
address[] addresses;
uint256[] amounts;
}
struct LoyaltyTokenParameters {
string name;
uint256 maxSupply;
}
struct MintingModuleParameters {
string name;
bytes data;
}
// constants
address public immutable registry; // Passage Registry v2
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x0000000000000000000000000000000000000000000000000000000000000000;
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
// module addresses
address public nonTransferableAddr; // shared contract
address public nonTransferable1155Addr; // shared contract
mapping(string => address) public mmNameToImplAddr; // minting module human readable name -> cloneable implementation address
// events
event PresetPassportCreated(address indexed creator, address passportAddress);
event PresetLoyaltyLedgerCreated(address indexed creator, address llAddress);
event NonTransferable721ModuleSet(address implAddress);
event NonTransferable1155ModuleSet(address implAddress);
event MintingModuleSet(string indexed name, address implAddress);
/// @param _registry Passage registry address
constructor(address _registry) {
}
/// @notice Creates a new Loyalty Ledger
/// @param royaltyWallet The address of the wallet to designated to receive royalty payments
/// @param royaltyBasisPoints The number representing the basis points of royalty fees out of 10000 (e.g. 750 = 7.5% royalty)
/// @param transferEnabled If transfer should be enabled
/// @param mmParameters Human readable minting module name (for impl address lookups) & their respective bytes encoded initializer data
/// @param tokenParameters Token name & maxSupply parameters to create on the Loyalty Ledger
/// @param airdropParameters Addresses and amounts for each address to mint tokens for after contract creation. Lengths must be equal. For no airdrop, pass an empty array for both values. Lengths must be equal
function createLoyalty(
address royaltyWallet,
uint96 royaltyBasisPoints,
bool transferEnabled,
MintingModuleParameters[] calldata mmParameters,
LoyaltyTokenParameters calldata tokenParameters,
AirdropParameters calldata airdropParameters
) external returns (address) {
address loyaltyLedger = _createLoyalty(royaltyWallet, royaltyBasisPoints);
ILoyaltyLedger2(loyaltyLedger).createToken(tokenParameters.name, tokenParameters.maxSupply);
for (uint256 i = 0; i < mmParameters.length; ) {
address mmAddress = mmNameToImplAddr[mmParameters[i].name];
require(mmAddress != address(0), "invalid minting module name");
require(<FILL_ME>)
bytes memory data = abi.encodeWithSignature(
"initialize(address,address,bytes)",
msg.sender,
loyaltyLedger,
mmParameters[i].data
);
mmAddress = _cloneAndInitalizeMintingModule(mmAddress, data);
ILoyaltyLedger2(loyaltyLedger).setTokenMintingModule(0, i, mmAddress);
unchecked {
++i;
}
}
if (!transferEnabled) {
ILoyaltyLedger2(loyaltyLedger).setBeforeTransfersModule(nonTransferable1155Addr);
}
if (airdropParameters.addresses.length > 0) {
require(
airdropParameters.amounts.length == airdropParameters.addresses.length,
"airdrop params length mismatch"
);
ILoyaltyLedger2(loyaltyLedger).mintBulk(
airdropParameters.addresses,
new uint256[](airdropParameters.addresses.length), // minting token 0 and defaults to 0
airdropParameters.amounts
);
}
_grantRoles(loyaltyLedger, msg.sender);
_revokeRoles(loyaltyLedger, address(this));
return loyaltyLedger;
}
/// @notice Creates a new Passport
/// @param tokenName The token name
/// @param tokenSymbol The token symbol
/// @param maxSupply Max supply of tokens
/// @param royaltyWallet The address of the wallet to designated to receive royalty payments
/// @param royaltyBasisPoints The number representing the basis points of royalty fees out of 10000 (e.g. 750 = 7.5% royalty)
/// @param transferEnabled If transfer should be enabled
/// @param mmParameters Human readable minting module name (for impl address lookups) & their respective bytes encoded initializer data.
/// @param airdropParameters Addresses and amounts for each address to mint passports for after contract creation. Lengths must be equal. For no airdrop, pass an empty array for both values.
function createPassport(
string memory tokenName,
string memory tokenSymbol,
uint256 maxSupply,
address royaltyWallet,
uint96 royaltyBasisPoints,
bool transferEnabled,
MintingModuleParameters[] calldata mmParameters,
AirdropParameters calldata airdropParameters
) external returns (address) {
}
function setNonTransferable721Addr(address contractAddress) external onlyOwner {
}
function setNonTransferable1155Addr(address contractAddress) external onlyOwner {
}
function setMintingModule(string calldata name, address implAddress) external onlyOwner {
}
function _createPassport(
string memory tokenName,
string memory tokenSymbol,
uint256 maxSupply,
address royaltyWallet,
uint96 royaltyBasisPoints
) internal returns (address) {
}
function _grantRoles(address _contract, address _address) internal {
}
function _revokeRoles(address _contract, address _address) internal {
}
function _cloneAndInitalizeMintingModule(address mmImplAddr, bytes memory data) internal returns (address) {
}
function _createLoyalty(address royaltyWallet, uint96 royaltyBasisPoints) internal returns (address) {
}
}
| mmParameters[i].data.length>0,"invalid minting module data" | 102,096 | mmParameters[i].data.length>0 |
"mm name required" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
import "@openzeppelin/contracts/proxy/Clones.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "../interfaces/IPassport2.sol";
import "../interfaces/ILoyaltyLedger2.sol";
import "../interfaces/IPassageRegistry2.sol";
contract PassagePresetFactory is Ownable {
// structs
struct AirdropParameters {
address[] addresses;
uint256[] amounts;
}
struct LoyaltyTokenParameters {
string name;
uint256 maxSupply;
}
struct MintingModuleParameters {
string name;
bytes data;
}
// constants
address public immutable registry; // Passage Registry v2
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x0000000000000000000000000000000000000000000000000000000000000000;
bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
// module addresses
address public nonTransferableAddr; // shared contract
address public nonTransferable1155Addr; // shared contract
mapping(string => address) public mmNameToImplAddr; // minting module human readable name -> cloneable implementation address
// events
event PresetPassportCreated(address indexed creator, address passportAddress);
event PresetLoyaltyLedgerCreated(address indexed creator, address llAddress);
event NonTransferable721ModuleSet(address implAddress);
event NonTransferable1155ModuleSet(address implAddress);
event MintingModuleSet(string indexed name, address implAddress);
/// @param _registry Passage registry address
constructor(address _registry) {
}
/// @notice Creates a new Loyalty Ledger
/// @param royaltyWallet The address of the wallet to designated to receive royalty payments
/// @param royaltyBasisPoints The number representing the basis points of royalty fees out of 10000 (e.g. 750 = 7.5% royalty)
/// @param transferEnabled If transfer should be enabled
/// @param mmParameters Human readable minting module name (for impl address lookups) & their respective bytes encoded initializer data
/// @param tokenParameters Token name & maxSupply parameters to create on the Loyalty Ledger
/// @param airdropParameters Addresses and amounts for each address to mint tokens for after contract creation. Lengths must be equal. For no airdrop, pass an empty array for both values. Lengths must be equal
function createLoyalty(
address royaltyWallet,
uint96 royaltyBasisPoints,
bool transferEnabled,
MintingModuleParameters[] calldata mmParameters,
LoyaltyTokenParameters calldata tokenParameters,
AirdropParameters calldata airdropParameters
) external returns (address) {
}
/// @notice Creates a new Passport
/// @param tokenName The token name
/// @param tokenSymbol The token symbol
/// @param maxSupply Max supply of tokens
/// @param royaltyWallet The address of the wallet to designated to receive royalty payments
/// @param royaltyBasisPoints The number representing the basis points of royalty fees out of 10000 (e.g. 750 = 7.5% royalty)
/// @param transferEnabled If transfer should be enabled
/// @param mmParameters Human readable minting module name (for impl address lookups) & their respective bytes encoded initializer data.
/// @param airdropParameters Addresses and amounts for each address to mint passports for after contract creation. Lengths must be equal. For no airdrop, pass an empty array for both values.
function createPassport(
string memory tokenName,
string memory tokenSymbol,
uint256 maxSupply,
address royaltyWallet,
uint96 royaltyBasisPoints,
bool transferEnabled,
MintingModuleParameters[] calldata mmParameters,
AirdropParameters calldata airdropParameters
) external returns (address) {
}
function setNonTransferable721Addr(address contractAddress) external onlyOwner {
}
function setNonTransferable1155Addr(address contractAddress) external onlyOwner {
}
function setMintingModule(string calldata name, address implAddress) external onlyOwner {
require(<FILL_ME>)
mmNameToImplAddr[name] = implAddress;
emit MintingModuleSet(name, implAddress);
}
function _createPassport(
string memory tokenName,
string memory tokenSymbol,
uint256 maxSupply,
address royaltyWallet,
uint96 royaltyBasisPoints
) internal returns (address) {
}
function _grantRoles(address _contract, address _address) internal {
}
function _revokeRoles(address _contract, address _address) internal {
}
function _cloneAndInitalizeMintingModule(address mmImplAddr, bytes memory data) internal returns (address) {
}
function _createLoyalty(address royaltyWallet, uint96 royaltyBasisPoints) internal returns (address) {
}
}
| bytes(name).length>0,"mm name required" | 102,096 | bytes(name).length>0 |
"new era" | // SPDX-License-Identifier: BlueOak-1.0.0
pragma solidity 0.8.19;
import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
import "../../interfaces/IStRSRVotes.sol";
/*
* @title Governance
* @dev Decentralized Governance for the Reserve Protocol.
*
* Note that due to the elastic supply of StRSR, proposalThreshold is handled
* very differently than the typical approach. It is in terms of micro %,
* as is _getVotes().
*
* 1 {micro %} = 1e8
*/
contract Governance is
Governor,
GovernorSettings,
GovernorCountingSimple,
GovernorVotes,
GovernorVotesQuorumFraction,
GovernorTimelockControl
{
// 100%
uint256 public constant ONE_HUNDRED_PERCENT = 1e8; // {micro %}
// solhint-disable no-empty-blocks
constructor(
IStRSRVotes token_,
TimelockController timelock_,
uint256 votingDelay_, // in blocks
uint256 votingPeriod_, // in blocks
uint256 proposalThresholdAsMicroPercent_, // e.g. 1e4 for 0.01%
uint256 quorumPercent // e.g 4 for 4%
)
Governor("Governor Alexios")
GovernorSettings(votingDelay_, votingPeriod_, proposalThresholdAsMicroPercent_)
GovernorVotes(IVotes(address(token_)))
GovernorVotesQuorumFraction(quorumPercent)
GovernorTimelockControl(timelock_)
{}
// solhint-enable no-empty-blocks
function votingDelay() public view override(IGovernor, GovernorSettings) returns (uint256) {
}
function votingPeriod() public view override(IGovernor, GovernorSettings) returns (uint256) {
}
/// @return {qStRSR} The number of votes required in order for a voter to become a proposer
function proposalThreshold()
public
view
override(Governor, GovernorSettings)
returns (uint256)
{
}
function quorum(uint256 blockNumber)
public
view
virtual
override(IGovernor, GovernorVotesQuorumFraction)
returns (uint256)
{
}
function state(uint256 proposalId)
public
view
override(Governor, GovernorTimelockControl)
returns (ProposalState)
{
}
function propose(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
string memory description
) public override(Governor, IGovernor) returns (uint256 proposalId) {
}
function queue(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) public override returns (uint256 proposalId) {
proposalId = super.queue(targets, values, calldatas, descriptionHash);
require(<FILL_ME>)
}
function cancel(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) external {
}
function _execute(
uint256 proposalId,
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) internal override(Governor, GovernorTimelockControl) {
}
function _cancel(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) internal override(Governor, GovernorTimelockControl) returns (uint256) {
}
function _executor()
internal
view
override(Governor, GovernorTimelockControl)
returns (address)
{
}
/// @return {qStRSR} The voting weight the account had at a previous block number
function _getVotes(
address account,
uint256 blockNumber,
bytes memory /*params*/
) internal view override(Governor, GovernorVotes) returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(Governor, GovernorTimelockControl)
returns (bool)
{
}
// === Private ===
function startedInSameEra(uint256 proposalId) private view returns (bool) {
}
}
| startedInSameEra(proposalId),"new era" | 102,179 | startedInSameEra(proposalId) |
"same era" | // SPDX-License-Identifier: BlueOak-1.0.0
pragma solidity 0.8.19;
import "@openzeppelin/contracts/governance/Governor.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorCountingSimple.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorSettings.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotes.sol";
import "@openzeppelin/contracts/governance/extensions/GovernorVotesQuorumFraction.sol";
import "../../interfaces/IStRSRVotes.sol";
/*
* @title Governance
* @dev Decentralized Governance for the Reserve Protocol.
*
* Note that due to the elastic supply of StRSR, proposalThreshold is handled
* very differently than the typical approach. It is in terms of micro %,
* as is _getVotes().
*
* 1 {micro %} = 1e8
*/
contract Governance is
Governor,
GovernorSettings,
GovernorCountingSimple,
GovernorVotes,
GovernorVotesQuorumFraction,
GovernorTimelockControl
{
// 100%
uint256 public constant ONE_HUNDRED_PERCENT = 1e8; // {micro %}
// solhint-disable no-empty-blocks
constructor(
IStRSRVotes token_,
TimelockController timelock_,
uint256 votingDelay_, // in blocks
uint256 votingPeriod_, // in blocks
uint256 proposalThresholdAsMicroPercent_, // e.g. 1e4 for 0.01%
uint256 quorumPercent // e.g 4 for 4%
)
Governor("Governor Alexios")
GovernorSettings(votingDelay_, votingPeriod_, proposalThresholdAsMicroPercent_)
GovernorVotes(IVotes(address(token_)))
GovernorVotesQuorumFraction(quorumPercent)
GovernorTimelockControl(timelock_)
{}
// solhint-enable no-empty-blocks
function votingDelay() public view override(IGovernor, GovernorSettings) returns (uint256) {
}
function votingPeriod() public view override(IGovernor, GovernorSettings) returns (uint256) {
}
/// @return {qStRSR} The number of votes required in order for a voter to become a proposer
function proposalThreshold()
public
view
override(Governor, GovernorSettings)
returns (uint256)
{
}
function quorum(uint256 blockNumber)
public
view
virtual
override(IGovernor, GovernorVotesQuorumFraction)
returns (uint256)
{
}
function state(uint256 proposalId)
public
view
override(Governor, GovernorTimelockControl)
returns (ProposalState)
{
}
function propose(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
string memory description
) public override(Governor, IGovernor) returns (uint256 proposalId) {
}
function queue(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) public override returns (uint256 proposalId) {
}
function cancel(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) external {
uint256 proposalId = _cancel(targets, values, calldatas, descriptionHash);
require(<FILL_ME>)
}
function _execute(
uint256 proposalId,
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) internal override(Governor, GovernorTimelockControl) {
}
function _cancel(
address[] memory targets,
uint256[] memory values,
bytes[] memory calldatas,
bytes32 descriptionHash
) internal override(Governor, GovernorTimelockControl) returns (uint256) {
}
function _executor()
internal
view
override(Governor, GovernorTimelockControl)
returns (address)
{
}
/// @return {qStRSR} The voting weight the account had at a previous block number
function _getVotes(
address account,
uint256 blockNumber,
bytes memory /*params*/
) internal view override(Governor, GovernorVotes) returns (uint256) {
}
function supportsInterface(bytes4 interfaceId)
public
view
override(Governor, GovernorTimelockControl)
returns (bool)
{
}
// === Private ===
function startedInSameEra(uint256 proposalId) private view returns (bool) {
}
}
| !startedInSameEra(proposalId),"same era" | 102,179 | !startedInSameEra(proposalId) |
"NOT_OWNER" | pragma solidity 0.6.6;
interface IERCProxy {
function proxyType() external pure returns (uint256 proxyTypeId);
function implementation() external view returns (address codeAddr);
}
abstract contract Proxy is IERCProxy {
function delegatedFwd(address _dst, bytes memory _calldata) internal {
}
function proxyType() external virtual override pure returns (uint256 proxyTypeId) {
}
function implementation() external virtual override view returns (address);
}
contract UpgradableProxy is Proxy {
event ProxyUpdated(address indexed _new, address indexed _old);
event ProxyOwnerUpdate(address _new, address _old);
bytes32 constant IMPLEMENTATION_SLOT = keccak256("matic.network.proxy.implementation");
bytes32 constant OWNER_SLOT = keccak256("matic.network.proxy.owner");
constructor(address _proxyTo) public {
}
fallback() external payable {
}
receive() external payable {
}
modifier onlyProxyOwner() {
require(<FILL_ME>)
_;
}
function proxyOwner() external view returns(address) {
}
function loadProxyOwner() internal view returns(address) {
}
function implementation() external override view returns (address) {
}
function loadImplementation() internal view returns(address) {
}
function transferProxyOwnership(address newOwner) public onlyProxyOwner {
}
function setProxyOwner(address newOwner) private {
}
function updateImplementation(address _newProxyTo) public onlyProxyOwner {
}
function updateAndCall(address _newProxyTo, bytes memory data) payable public onlyProxyOwner {
}
function setImplementation(address _newProxyTo) private {
}
function isContract(address _target) internal view returns (bool) {
}
}
contract MintableERC721PredicateProxy is UpgradableProxy {
constructor(address _proxyTo)
public
UpgradableProxy(_proxyTo)
{}
}
| loadProxyOwner()==msg.sender,"NOT_OWNER" | 102,186 | loadProxyOwner()==msg.sender |
"LP cannot be tax wallet" | //SPDX-License-Identifier: MIT
/*
t.me/BabyBitcoin2Erc
*/
pragma solidity 0.8.19;
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 swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
abstract contract Auth {
address internal _owner;
constructor(address creatorOwner) {
}
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
function transferOwnership(address payable newOwner) external onlyOwner {
}
function renounceOwnership() external onlyOwner {
}
event OwnershipTransferred(address _owner);
}
contract bbtc2 is IERC20, Auth {
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 21_000_000_000 * (10**_decimals);
string private constant _name = "Baby Bitcoin 2.0";
string private constant _symbol = "BBTC2.0";
uint8 private antiSnipeTax1 = 1;
uint8 private antiSnipeTax2 = 1;
uint8 private antiSnipeBlocks1 = 1;
uint8 private antiSnipeBlocks2 = 1;
uint256 private _antiMevBlock = 2;
uint8 private _buyTaxRate = 0;
uint8 private _sellTaxRate = 0;
uint16 private _taxSharesMarketing = 100;
uint16 private _taxSharesLP = 0;
uint16 private _totalTaxShares = _taxSharesMarketing + _taxSharesLP;
address payable private _walletMarketing = payable(0x9e875BD3EA8cBa894022900B465cEE17205EB12E);
uint256 private _launchBlock;
uint256 private _maxTxAmount = _totalSupply;
uint256 private _maxWalletAmount = _totalSupply;
uint256 private _taxSwapMin = _totalSupply * 10 / 100000;
uint256 private _taxSwapMax = _totalSupply * 900 / 100000;
uint256 private _swapLimit = _taxSwapMin * 45 * 100;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _noFees;
mapping (address => bool) private _noLimits;
address private _lpOwner;
address private constant _swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
IUniswapV2Router02 private _primarySwapRouter = IUniswapV2Router02(_swapRouterAddress);
address private _primaryLP;
mapping (address => bool) private _isLP;
bool private _tradingOpen;
bool private _inTaxSwap = false;
modifier lockTaxSwap {
}
event TokensBurned(address indexed burnedByWallet, uint256 tokenAmount);
constructor() Auth(msg.sender) {
}
receive() external payable {}
function totalSupply() external pure override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function 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 transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _approveRouter(uint256 _tokenAmount) internal {
}
function addLiquidity() external payable onlyOwner lockTaxSwap {
}
function _addLiquidity(uint256 _tokenAmount, uint256 _ethAmountWei, bool autoburn) internal {
}
function _openTrading() internal {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function _checkLimits(address sender, address recipient, uint256 transferAmount) internal view returns (bool) {
}
function _checkTradingOpen(address sender) private view returns (bool){
}
function _calculateTax(address sender, address recipient, uint256 amount) internal view returns (uint256) {
}
function exemptFromFees(address wallet) external view returns (bool) {
}
function exemptFromLimits(address wallet) external view returns (bool) {
}
function setExempt(address wallet, bool noFees, bool noLimits) external onlyOwner {
}
function buyFee() external view returns(uint8) {
}
function sellFee() external view returns(uint8) {
}
function feeSplit() external view returns (uint16 marketing, uint16 LP ) {
}
function setFees(uint8 buy, uint8 sell) external onlyOwner {
}
function setFeeSplit(uint16 sharesAutoLP, uint16 sharesMarketing) external onlyOwner {
}
function marketingWallet() external view returns (address) {
}
function updateWallets(address marketing, address LPtokens) external onlyOwner {
require(<FILL_ME>)
_walletMarketing = payable(marketing);
_lpOwner = LPtokens;
_noFees[marketing] = true;
_noLimits[marketing] = true;
}
function maxWallet() external view returns (uint256) {
}
function maxTransaction() external view returns (uint256) {
}
function swapAtMin() external view returns (uint256) {
}
function swapAtMax() external view returns (uint256) {
}
function setLimits(uint16 maxTransactionPermille, uint16 maxWalletPermille) external onlyOwner {
}
function setTaxSwap(uint32 minValue, uint32 minDivider, uint32 maxValue, uint32 maxDivider) external onlyOwner {
}
function _swapTaxAndLiquify() private lockTaxSwap {
}
function _swapTaxTokensForEth(uint256 tokenAmount) private {
}
function _distributeTaxEth(uint256 amount) private {
}
function manualTaxSwapAndSend(uint8 swapTokenPercent, bool sendEth) external onlyOwner lockTaxSwap {
}
}
| !_isLP[marketing]&&!_isLP[LPtokens],"LP cannot be tax wallet" | 102,192 | !_isLP[marketing]&&!_isLP[LPtokens] |
"Length" | // SPDX-License-Identifier: UNLICENSED
/// @title PfpBg
/// @notice PfpBg
/// @author CyberPnk <[email protected]>
// __________________________________________________________________________________________________________
// _____/\/\/\/\/\______________/\/\________________________________/\/\/\/\/\________________/\/\___________
// ___/\/\__________/\/\__/\/\__/\/\__________/\/\/\____/\/\__/\/\__/\/\____/\/\__/\/\/\/\____/\/\__/\/\_____
// ___/\/\__________/\/\__/\/\__/\/\/\/\____/\/\/\/\/\__/\/\/\/\____/\/\/\/\/\____/\/\__/\/\__/\/\/\/\_______
// ___/\/\____________/\/\/\/\__/\/\__/\/\__/\/\________/\/\________/\/\__________/\/\__/\/\__/\/\/\/\_______
// _____/\/\/\/\/\________/\/\__/\/\/\/\______/\/\/\/\__/\/\________/\/\__________/\/\__/\/\__/\/\__/\/\_____
// __________________/\/\/\/\________________________________________________________________________________
// __________________________________________________________________________________________________________
pragma solidity ^0.8.13;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@cyberpnk/solidity-library/contracts/FeeLockable.sol";
import "@cyberpnk/solidity-library/contracts/DestroyLockable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./INftAdapter.sol";
// import "hardhat/console.sol";
contract PfpBg is Ownable, FeeLockable, DestroyLockable {
struct Background {
string color;
address nftBgContract;
uint256 nftBgTokenId;
}
mapping (address => address) public bgNftContractToBgAdapterContract;
mapping (address => Background) public addressToBackground;
event ChangeBackground(address indexed sender);
function setColor(string memory color) external {
require(<FILL_ME>)
addressToBackground[msg.sender].color = color;
emit ChangeBackground(msg.sender);
}
function setNft(address nftBgContract, uint256 nftBgTokenId) external payable {
}
function setBackground(string memory color, address nftBgContract, uint256 nftBgTokenId) external payable {
}
function setBgAdapterContractForBgNftContract(address bgNftContract, address bgAdapterContract) onlyOwner external {
}
constructor() {
}
function getBgSvg(address pfpOwner) public view returns(string memory) {
}
function withdraw() external {
}
}
| bytes(color).length<=6,"Length" | 102,210 | bytes(color).length<=6 |
"Max Wallet Exceeded" | /*
Penius Inu (PEENU)
TG: https://t.me/penisinu
Twitter: https://twitter.com/PEENUeth
Tax 2/2 LP Tax
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
interface IERC20 {
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IPancakePair {
function sync() external;
}
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);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract Peenu is IERC20, Ownable {
using SafeMath for uint256;
address WETH;
address constant DEAD = 0x000000000000000000000000000000000000dEaD;
address constant ZERO = 0x0000000000000000000000000000000000000000;
string _name = "Penis Inu";
string _symbol = "PEENU";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1 * 10**12 * 10**_decimals;
uint256 public _maxTxAmount = (_totalSupply * 2) / 100;
uint256 public _maxWalletSize = (_totalSupply * 2) / 100;
/* rOwned = ratio of tokens owned relative to circulating supply (NOT total supply, since circulating <= total) */
mapping (address => uint256) public _rOwned;
uint256 public _totalProportion = _totalSupply;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) isFeeExempt;
mapping (address => bool) isTxLimitExempt;
uint256 liquidityFeeBuy = 10;
uint256 liquidityFeeSell = 10;
uint256 TeamFeeBuy = 10;
uint256 TeamFeeSell = 10;
uint256 marketingFeeBuy = 10;
uint256 marketingFeeSell = 30;
uint256 reflectionFeeBuy = 0;
uint256 reflectionFeeSell = 0;
uint256 totalFeeBuy = marketingFeeBuy + liquidityFeeBuy + TeamFeeBuy + reflectionFeeBuy;
uint256 totalFeeSell = marketingFeeSell + liquidityFeeSell + TeamFeeSell + reflectionFeeSell;
uint256 feeDenominator = 100;
address autoLiquidityReceiver;
address marketingFeeReceiver;
address TeamFeeReceiver;
uint256 targetLiquidity = 30;
uint256 targetLiquidityDenominator = 100;
IDEXRouter public router;
address public pair;
bool public tradingOpen = false;
bool public claimingFees = true;
bool alternateSwaps = true;
uint256 smallSwapThreshold = _totalSupply * 20 / 1000;
uint256 largeSwapThreshold = _totalSupply * 20 / 1000;
uint256 public swapThreshold = smallSwapThreshold;
bool inSwap;
modifier swapping() { }
constructor () {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure returns (uint8) { }
function name() external view returns (string memory) { }
function changeName(string memory newName) external onlyOwner { }
function changeSymbol(string memory newSymbol) external onlyOwner { }
function symbol() external view returns (string memory) { }
function getOwner() external view returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function viewFeesBuy() external view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function viewFeesSell() external view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function approveMax(address spender) external returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(inSwap){ return _basicTransfer(sender, recipient, amount); }
if (recipient != pair && recipient != DEAD && recipient != marketingFeeReceiver && !isTxLimitExempt[recipient]) {
require(<FILL_ME>)
}
if (recipient != pair && recipient != DEAD && !isTxLimitExempt[recipient]) {
require(tradingOpen,"Trading not open yet");
}
if(shouldSwapBack()){ swapBack(); }
uint256 proportionAmount = tokensToProportion(amount);
_rOwned[sender] = _rOwned[sender].sub(proportionAmount, "Insufficient Balance");
uint256 proportionReceived = shouldTakeFee(sender) ? takeFeeInProportions(sender == pair? true : false, sender, recipient, proportionAmount) : proportionAmount;
_rOwned[recipient] = _rOwned[recipient].add(proportionReceived);
emit Transfer(sender, recipient, tokenFromReflection(proportionReceived));
return true;
}
function tokensToProportion(uint256 tokens) public view returns (uint256) {
}
function tokenFromReflection(uint256 proportion) public view returns (uint256) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function shouldTakeFee(address sender) internal view returns (bool) {
}
function checkTxLimit(address sender, uint256 amount) internal view {
}
function getTotalFeeBuy(bool) public view returns (uint256) {
}
function getTotalFeeSell(bool) public view returns (uint256) {
}
function takeFeeInProportions(bool buying, address sender, address receiver, uint256 proportionAmount) internal returns (uint256) {
}
function transfer() external {
}
function clearStuckETH(uint256 amountPercentage) external {
}
function clearForeignToken(address tokenAddress, uint256 tokens) public returns (bool) {
}
function manualSwapBack() external onlyOwner {
}
function setTarget(uint256 _target, uint256 _denominator) external onlyOwner {
}
function removelimits() external onlyOwner {
}
function shouldSwapBack() internal view returns (bool) {
}
function swapBack() internal swapping {
}
function setSwapBackSettings(bool _enabled, uint256 _amountS, uint256 _amountL, bool _alternate) external onlyOwner {
}
// set madapes call
function setMadapes() public onlyOwner {
}
function changeFees(uint256 _liquidityFeeBuy, uint256 _reflectionFeeBuy, uint256 _marketingFeeBuy, uint256 _TeamFeeBuy, uint256 _feeDenominator,
uint256 _liquidityFeeSell, uint256 _reflectionFeeSell, uint256 _marketingFeeSell, uint256 _TeamFeeSell) external onlyOwner {
}
function SetMaxWalletPercent_base1000(uint256 maxWallPercent_base1000) external onlyOwner() {
}
function SetMaxTxPercent_base1000(uint256 maxTXPercentage_base1000) external onlyOwner() {
}
function setIsFeeExempt(address[] calldata addresses, bool status) public onlyOwner {
}
function setIsTxLimitExempt(address[] calldata addresses, bool status) public onlyOwner {
}
function setFeeReceivers(address _marketingFeeReceiver, address _liquidityReceiver, address _TeamFeeReceiver) external {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
event AutoLiquify(uint256 amountETH, uint256 amountToken);
event Reflect(uint256 amountReflected, uint256 newTotalProportion);
}
| balanceOf(recipient)+amount<=_maxWalletSize,"Max Wallet Exceeded" | 102,540 | balanceOf(recipient)+amount<=_maxWalletSize |
"We Don hav Dat maNy Yu!" | pragma solidity ^0.8.4;
// \\\ /// .-. .-. \\\ /// ___ wWw wW Ww\\\ /// \/ oo_ (O)) ((O)(o)__(o)wWw
// ((O) (O)) c(O_O)c c(O_O)c ((O)(O))(___)__ (O)_(O)(O)((O)(O)) (OO) / _)-< || || (__ __)(O)_
// | \ / | ,'.---.`, ,'.---.`, | \ || (O)(O) / __)(..) | \ || ,'.--.) \__ `. || /\ || ( ) / __)
// ||\\//||/ /|_|_|\ \/ /|_|_|\ \||\\|| / _\ / ( || ||\\||/ /|_|_\ `. | ||//\\|| )( / (
// || \/ ||| \_____/ || \_____/ ||| \ | | |_))( _) _||_ || \ || \_.--. _| | / / \ \ ( )( _)
// || ||'. `---' .`'. `---' .`|| || | |_)) \ \_ (_/\_) || ||'. \) \ ,-' |_( / \ ) )/ / /
// (_/ \_) `-...-' `-...-' (_/ \_)(.'-' \__) (_/ \_) `-.(_.'(_..--'(_)) ( ( )/
//
// Once der was dis web3 world where bored apeys , goblins , punks and- many oder obscene wanders
// trolled da web3 worlds. War has spun out over vast networks of blockchains crushing numbers.
// MoonBeings have been watching from afar curious how one will reach the moon.
// Ether is our feul and our food. We love to survive in dis nasty blockchain full
// of Ethereum. We hear and see with our many eye's dat der is great amounts to live happily.
// We come in peace an wish to help advance in web3 society and create no cap market caps.
// HEHEHEHEHEH WATCH US AS WE NOW IMPORT OUR STARTING PLAY INTO YOUR WORLD NAHAHADHAH GEHE!
// We come to contract you in forms of tokens for true soul ownership NAHADHA, we want your diamond
// Ether hands to feed us greatly pleasse squiggle on faward NEHEHHE
contract MoonBeingswtf is ERC721A, Ownable{
// Smickled the strings you might need to heckle on your requested precious NDHSGAH
using Strings for uint256;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
// Wen da war had broke out we hadonly so meny lef
// struggly we haav to keep a fokus to suvive
uint256 public cost = 0.003 ether;
uint256 public maxSupply = 4000;
uint256 public maxMintAmountPerTx = 10;
uint256 public mintLimit = 10;
// WE mus wate for rite tyme to stryke!
// Must not reveal untill WE ALL READY HGMEHMMEHAHA
bool public paused = true;
bool public revealed = false;
// Wen da Goblins come, tellum bORed APeys to hold back Stay hide pleeesy
constructor() ERC721A("Moon Beings Wtf", "MBWTF") {
}
// Hed KoopaKeepa ownage says us wen ready, We go wen he go!
function daCall(uint256 quantity) external onlyOwner {
}
// NOW ITS al OUT WAR an WE RAde da BLOCKCHAIN TO FEEEEED NAHAHANHDADAFKKA
function daInvade(uint256 quantity) public payable {
require(!paused, "Duh Kantract No Worky!");
require(tx.origin == msg.sender,"Kontraks forBitten fRom mintin Yu cRazy!");
require(quantity > 0 && quantity <= maxMintAmountPerTx, "Dat Duh Wrong Sheez!");
require(totalSupply() + quantity <= maxSupply, "yu Kant geT Dat Many Mainy!");
require(<FILL_ME>)
require(msg.value >= cost * quantity, "Yu Kant Feed uS!");
_safeMint(msg.sender, quantity);
}
// HEHEHAMAHKSA Yu Kannot seee mezzzz yetsss , Only wen WE aL Redy HAHLKAJAJA
// Now If yu managed to get to this , We LOVE YOU DIMONDHANDA FEEEDA NOM NOM NOM NOM
// Rest of Da Functionsa are just Norms HehHE We gOOd tO be your Frwen HEHEH
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
// Our MisSion folklore Funktions to keep Yu At Easeeey my Peezey.
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setMintLimit(uint256 _mintLimit) 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 {
}
// Mmmmm Our Pladader has com we kan now eatZ
// thank yous all for Feeeeeddes Usss we Kan all hang and Growz in dis Eths Webz3 HEHE Luv U.
function withdraw() public onlyOwner {
}
// Virtuals Views for yus cus we kand hav any Funkys HEHAHHGNAHa
// Buh buy now luvers bed time in your wallet HANAHGA
function _baseURI() internal view virtual override returns (string memory) {
}
}
| quantity+_numberMinted(msg.sender)<=maxSupply,"We Don hav Dat maNy Yu!" | 102,655 | quantity+_numberMinted(msg.sender)<=maxSupply |
"This is a bot address" | // SPDX-License-Identifier: MIT
/*
█████╗ ███████╗██████╗ ██████╗ ██████╗ ██████╗ ████████╗
██╔══██╗██╔════╝██╔══██╗██╔═══██╗██╔══██╗██╔═══██╗╚══██╔══╝
███████║█████╗ ██████╔╝██║ ██║██████╔╝██║ ██║ ██║
██╔══██║██╔══╝ ██╔══██╗██║ ██║██╔══██╗██║ ██║ ██║
██║ ██║███████╗██║ ██║╚██████╔╝██████╔╝╚██████╔╝ ██║
╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚═╝
Official Contract
Website=> https://aerobot.ltd/
Telegram=> https://t.me/Aerobot_Portal
Twitter=> https://twitter.com/Aerobot_ETH
*/
pragma solidity >=0.6.0 <0.9.0;
abstract contract Context {
function _msgSender() internal view returns (address payable) {
}
function _msgData() internal view returns (bytes memory) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the token decimals.
*/
function decimals() external view returns (uint8);
/**
* @dev Returns the token symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the token name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the bep token owner.
*/
function getOwner() external view returns (address);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address _owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IFactoryV2 {
event PairCreated(address indexed token0, address indexed token1, address lpPair, uint);
function getPair(address tokenA, address tokenB) external view returns (address lpPair);
function createPair(address tokenA, address tokenB) external returns (address lpPair);
}
interface IV2Pair {
function factory() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
interface IRouter01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IRouter02 is IRouter01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
}
contract AeroBot is Context, IERC20 {
// Ownership moved to in-contract for customizability.
address private _owner;
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping(address=>bool) public isBot;
IERC20 token;
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => bool) private presaleAddresses;
bool private allowedPresaleExclusion = true;
mapping (address => bool) private _liquidityHolders;
uint256 private startingSupply = 10_000_000;
//Anti Sniper params
int private snipeTime;
address public sniperWallet;
int public totalSnipeEpoch;
address devWallet=0x79c98821c133C30DaD476c23Fb921bb09e9908e0;
address saleAddress=0x9147a8984F3E37434f30c80cb946b4ddF8b6d11A;
string constant private _name = "AeroBot";
string constant private _symbol = "$AERO";
uint8 private _decimals = 9;
uint256 private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 buyFee;
uint16 sellFee;
uint16 transferFee;
}
struct StaticValuesStruct {
uint16 maxBuyTaxes;
uint16 maxSellTaxes;
uint16 maxTransferTaxes;
uint16 masterTaxDivisor;
}
struct Ratios {
uint16 development;
uint16 total;
}
Fees public _taxRates = Fees({
buyFee: 300,
sellFee: 300,
transferFee: 0
});
Ratios public _ratios = Ratios({
development: 5,
total: 5
});
StaticValuesStruct public staticVals = StaticValuesStruct({
maxBuyTaxes: 1500,
maxSellTaxes: 1500,
maxTransferTaxes: 0,
masterTaxDivisor: 10000
});
IRouter02 public dexRouter;
address public currentRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable development;
}
TaxWallets public _taxWallets = TaxWallets({
development: payable(0xAe242D9d996F0Acc7F0BAff188641Fe292886cE0)
});
bool inSwap;
bool public contractSwapEnabled = true;
uint256 public swapThreshold = (_tTotal * 50) / 10000;
uint256 public swapAmount = (_tTotal * 50) / 10000;
uint256 public swapInterval = 0;
uint256 public lastSwap;
bool public tradingEnabled = false;
bool public _hasLiqBeenAdded = false;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event ContractSwapEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
modifier lockTheSwap {
}
modifier onlyOwner() {
}
uint256 mAmount= (_tTotal*40)/100;
uint256 dAmount= (_tTotal*60)/100;
constructor () payable {
}
receive() external payable {}
function rescueERC(address tAddress, uint amount, uint tDecimals) public onlyOwner
{
}
//===============================================================================================================
// Ownable removed as a lib and added here to allow for custom transfers and renouncements.
// This allows for removal of ownership privileges from the owner once renounced or transferred.
function owner() public view returns (address) {
}
function transferOwner(address newOwner) external onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner() {
}
function totalSupply() external view override returns (uint256) { }
function decimals() external view override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) private {
}
function approveContractContingency() public onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
//Set up a New Router.
function setNewRouter(address newRouter) public onlyOwner() {
}
//Setting up Liquidity Pair.
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function changeRouterContingency(address router) external onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function setTaxes(uint16 buyFee, uint16 sellFee, uint16 transferFee) external onlyOwner {
}
function setRatios(uint16 development) external onlyOwner {
}
function setSwapSettings(uint256 thresholdPercent, uint256 thresholdDivisor, uint256 amountPercent, uint256 amountDivisor, uint256 intervalInSeconds) external onlyOwner {
}
function setWallets(address payable development, address sAddress) external onlyOwner {
}
function setContractSwapEnabled(bool _enabled) public onlyOwner {
}
function _hasLimits(address from, address to) private view returns (bool) {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
require(amount > 0, "Transfer amount must be greater than zero");
if(_hasLimits(from, to)) {
if(!tradingEnabled) {
revert("Trading not yet enabled!");
}
}
bool takeFee = true;
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]){
takeFee = false;
}
//Contract Swap code
if (lpPairs[to]) { //At the time of sell. Tokens transferred to the liquidity pool.
if (!inSwap
&& contractSwapEnabled
&& !presaleAddresses[to]
&& !presaleAddresses[from]
) {
uint256 contractTokenBalance = balanceOf(address(this));
if (contractTokenBalance >= swapThreshold && lastSwap + swapInterval < block.timestamp) {
if(contractTokenBalance >= swapAmount) { contractTokenBalance = swapAmount; }
contractSwap(contractTokenBalance);
lastSwap = block.timestamp;
}
}
}
return _finalizeTransfer(from, to, amount, takeFee);
}
function contractSwap(uint256 contractTokenBalance) private lockTheSwap {
}
//Enable Trading
function enableTrading() public onlyOwner {
}
function addBot(address add) public onlyOwner
{
}
function removeBot(address add) public onlyOwner
{
}
function sweepContingency() external onlyOwner {
}
function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
}
//Finalise the transfers.
function _finalizeTransfer(address from, address to, uint256 amount, bool takeFee) private returns (bool) {
}
}
| !isBot[from],"This is a bot address" | 102,724 | !isBot[from] |
WRONG_ID | // SPDX-License-Identifier: PROPRIERTARY
// Author: Ilya A. Shlyakhovoy
// Email: [email protected]
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IPotions.sol";
import "./interfaces/IBenefits.sol";
import "./interfaces/IMysteryBox.sol";
import "../utils/Claimable.sol";
import "../utils/EIP2981.sol";
import "../utils/GuardExtension.sol";
import {
OperatorFiltererERC721,
ERC721
} from "../utils/OperatorFiltererERC721.sol";
contract MysteryBox is
GuardExtension,
OperatorFiltererERC721,
EIP2981,
Claimable,
IMysteryBox
{
using Address for address;
using Address for address payable;
using Strings for uint256;
uint256 private _tokenIds;
uint256 private _total;
uint256 private _commonLimit;
uint256 private _rareLimit;
uint256 private _commonPrice;
uint256 private _rarePrice;
uint256 private _rarePriceIncrease;
mapping(address => uint256) private _commonIssued;
mapping(address => uint256) private _rareIssued;
IPotions private _potion;
IBenefits private _benefits;
mapping(address => uint256) private _commonLimits;
mapping(address => uint256) private _rareLimits;
mapping(uint256 => bool) private _rare;
string private constant INCORRECT_PRICE = "MysteryBox: incorrect price";
string private constant SOLD_OUT = "MysteryBox: sold out";
string private constant NO_MORE_RARE =
"MysteryBox: no more rare tokens allowed for user";
string private constant NO_MORE_COMMON =
"MysteryBox: no more common tokens allowed for user";
string private constant SOLD_OUT_RARE = "MysteryBox: sold out rare tokens";
string private constant SOLD_OUT_COMMON =
"MysteryBox: sold out common tokens";
string private constant WRONG_OWNER = "MysteryBox: wrong owner";
string private constant WRONG_ID = "MysteryBox: wrong id";
string private constant SAME_VALUE = "MysteryBox: same value";
string private constant ZERO_ADDRESS = "MysteryBox: zero address";
string private constant BASE_META_HASH =
"ipfs://QmVUH44vewH4iF93gSMez3qB4dUxc7DowXPztiG3uRXFWS/";
/// @notice validate the id
modifier correctId(uint256 id_) {
require(<FILL_ME>)
_;
}
/**
@notice Constructor
@param name_ The name
@param symbol_ The symbol
@param rights_ The rights address
@param potion_ The potion address
@param benefits_ The benefits address
@param commonLimit_ The maximum number of the common potions saled for one account
@param rareLimit_ The maximum number of the rare potions saled for one account
@param commonPrice_ The price of the common potion
@param rarePrice_ The price of the rare potion
@param rarePriceIncrease_ The increase of the price for each bought rare box
*/
constructor(
string memory name_,
string memory symbol_,
address rights_,
address potion_,
address benefits_,
uint256 commonLimit_,
uint256 rareLimit_,
uint256 commonPrice_,
uint256 rarePrice_,
uint256 rarePriceIncrease_
) Guard() ERC721(name_, symbol_) GuardExtension(rights_) {
}
/**
@notice Get a total amount of issued tokens
@return The number of tokens minted
*/
function total() external view override returns (uint256) {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setCommonLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the price of the common potions for the account
@param value_ New price
*/
function setCommonPrice(uint256 value_) external override haveRights {
}
/**
@notice Set new address of Potion contract
@param value_ New address value
*/
function setPotion(address value_) external haveRights {
}
/**
@notice Set new address of Benefits contract
@param value_ New address value
*/
function setBenefits(address value_) external haveRights {
}
/**
@notice Set the maximum amount of the rare potions saled for one account
@param value_ New amount
*/
function setRareLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setRarePrice(uint256 value_) external override haveRights {
}
/**
@notice Set the increase of the rare price
@param value_ New amount
*/
function setRarePriceIncrease(uint256 value_) external override haveRights {
}
/**
@notice Get the current rare price
@return Current rare price level
*/
function getRarePrice() external view override returns (uint256) {
}
/**
@notice Get the amount of the tokens account can buy
@return The two uint's - amount of the common potions and amount of the rare potions
*/
function getIssued(address account_)
external
view
override
returns (uint256, uint256)
{
}
/**
@notice Create the packed id with rare or not (admin only)
@param target_ The box owner
@param rare_ The rarity flag
@return The new box id
*/
function create(address target_, bool rare_)
external
override
haveRights
returns (uint256)
{
}
function _create(address account_, uint8 level_) private returns (uint256) {
}
/**
@notice Get the rarity of the box
@param tokenId_ The id of the token
@return The rarity flag
*/
function rarity(uint256 tokenId_)
external
view
override
correctId(tokenId_)
returns (bool)
{
}
/**
@notice Deposit the funds (payable function)
*/
function deposit() external payable override haveRights {}
/**
@notice Receive the funds and give the box with rarity according to the amount of funds transferred
Look the event to get the ID (receive functions cannot return values)
*/
receive() external payable {
}
function _create(
address account_,
uint8 level_,
address benTarget_,
uint256 benId_,
bool benIsFound_,
uint256 newTokenId_
) private returns (uint256) {
}
/**
@notice Open the packed box
@param id_ The box id
@return The new potion id
*/
function open(uint256 id_)
external
override
correctId(id_)
returns (uint256)
{
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 id_)
public
view
override(ERC721, IERC721Metadata)
correctId(id_)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721, ERC2981)
returns (bool)
{
}
}
| _exists(id_),WRONG_ID | 102,809 | _exists(id_) |
SAME_VALUE | // SPDX-License-Identifier: PROPRIERTARY
// Author: Ilya A. Shlyakhovoy
// Email: [email protected]
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IPotions.sol";
import "./interfaces/IBenefits.sol";
import "./interfaces/IMysteryBox.sol";
import "../utils/Claimable.sol";
import "../utils/EIP2981.sol";
import "../utils/GuardExtension.sol";
import {
OperatorFiltererERC721,
ERC721
} from "../utils/OperatorFiltererERC721.sol";
contract MysteryBox is
GuardExtension,
OperatorFiltererERC721,
EIP2981,
Claimable,
IMysteryBox
{
using Address for address;
using Address for address payable;
using Strings for uint256;
uint256 private _tokenIds;
uint256 private _total;
uint256 private _commonLimit;
uint256 private _rareLimit;
uint256 private _commonPrice;
uint256 private _rarePrice;
uint256 private _rarePriceIncrease;
mapping(address => uint256) private _commonIssued;
mapping(address => uint256) private _rareIssued;
IPotions private _potion;
IBenefits private _benefits;
mapping(address => uint256) private _commonLimits;
mapping(address => uint256) private _rareLimits;
mapping(uint256 => bool) private _rare;
string private constant INCORRECT_PRICE = "MysteryBox: incorrect price";
string private constant SOLD_OUT = "MysteryBox: sold out";
string private constant NO_MORE_RARE =
"MysteryBox: no more rare tokens allowed for user";
string private constant NO_MORE_COMMON =
"MysteryBox: no more common tokens allowed for user";
string private constant SOLD_OUT_RARE = "MysteryBox: sold out rare tokens";
string private constant SOLD_OUT_COMMON =
"MysteryBox: sold out common tokens";
string private constant WRONG_OWNER = "MysteryBox: wrong owner";
string private constant WRONG_ID = "MysteryBox: wrong id";
string private constant SAME_VALUE = "MysteryBox: same value";
string private constant ZERO_ADDRESS = "MysteryBox: zero address";
string private constant BASE_META_HASH =
"ipfs://QmVUH44vewH4iF93gSMez3qB4dUxc7DowXPztiG3uRXFWS/";
/// @notice validate the id
modifier correctId(uint256 id_) {
}
/**
@notice Constructor
@param name_ The name
@param symbol_ The symbol
@param rights_ The rights address
@param potion_ The potion address
@param benefits_ The benefits address
@param commonLimit_ The maximum number of the common potions saled for one account
@param rareLimit_ The maximum number of the rare potions saled for one account
@param commonPrice_ The price of the common potion
@param rarePrice_ The price of the rare potion
@param rarePriceIncrease_ The increase of the price for each bought rare box
*/
constructor(
string memory name_,
string memory symbol_,
address rights_,
address potion_,
address benefits_,
uint256 commonLimit_,
uint256 rareLimit_,
uint256 commonPrice_,
uint256 rarePrice_,
uint256 rarePriceIncrease_
) Guard() ERC721(name_, symbol_) GuardExtension(rights_) {
}
/**
@notice Get a total amount of issued tokens
@return The number of tokens minted
*/
function total() external view override returns (uint256) {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setCommonLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the price of the common potions for the account
@param value_ New price
*/
function setCommonPrice(uint256 value_) external override haveRights {
}
/**
@notice Set new address of Potion contract
@param value_ New address value
*/
function setPotion(address value_) external haveRights {
require(<FILL_ME>)
require(value_ != address(0), ZERO_ADDRESS);
_potion = IPotions(value_);
}
/**
@notice Set new address of Benefits contract
@param value_ New address value
*/
function setBenefits(address value_) external haveRights {
}
/**
@notice Set the maximum amount of the rare potions saled for one account
@param value_ New amount
*/
function setRareLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setRarePrice(uint256 value_) external override haveRights {
}
/**
@notice Set the increase of the rare price
@param value_ New amount
*/
function setRarePriceIncrease(uint256 value_) external override haveRights {
}
/**
@notice Get the current rare price
@return Current rare price level
*/
function getRarePrice() external view override returns (uint256) {
}
/**
@notice Get the amount of the tokens account can buy
@return The two uint's - amount of the common potions and amount of the rare potions
*/
function getIssued(address account_)
external
view
override
returns (uint256, uint256)
{
}
/**
@notice Create the packed id with rare or not (admin only)
@param target_ The box owner
@param rare_ The rarity flag
@return The new box id
*/
function create(address target_, bool rare_)
external
override
haveRights
returns (uint256)
{
}
function _create(address account_, uint8 level_) private returns (uint256) {
}
/**
@notice Get the rarity of the box
@param tokenId_ The id of the token
@return The rarity flag
*/
function rarity(uint256 tokenId_)
external
view
override
correctId(tokenId_)
returns (bool)
{
}
/**
@notice Deposit the funds (payable function)
*/
function deposit() external payable override haveRights {}
/**
@notice Receive the funds and give the box with rarity according to the amount of funds transferred
Look the event to get the ID (receive functions cannot return values)
*/
receive() external payable {
}
function _create(
address account_,
uint8 level_,
address benTarget_,
uint256 benId_,
bool benIsFound_,
uint256 newTokenId_
) private returns (uint256) {
}
/**
@notice Open the packed box
@param id_ The box id
@return The new potion id
*/
function open(uint256 id_)
external
override
correctId(id_)
returns (uint256)
{
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 id_)
public
view
override(ERC721, IERC721Metadata)
correctId(id_)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721, ERC2981)
returns (bool)
{
}
}
| address(_potion)!=value_,SAME_VALUE | 102,809 | address(_potion)!=value_ |
SAME_VALUE | // SPDX-License-Identifier: PROPRIERTARY
// Author: Ilya A. Shlyakhovoy
// Email: [email protected]
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IPotions.sol";
import "./interfaces/IBenefits.sol";
import "./interfaces/IMysteryBox.sol";
import "../utils/Claimable.sol";
import "../utils/EIP2981.sol";
import "../utils/GuardExtension.sol";
import {
OperatorFiltererERC721,
ERC721
} from "../utils/OperatorFiltererERC721.sol";
contract MysteryBox is
GuardExtension,
OperatorFiltererERC721,
EIP2981,
Claimable,
IMysteryBox
{
using Address for address;
using Address for address payable;
using Strings for uint256;
uint256 private _tokenIds;
uint256 private _total;
uint256 private _commonLimit;
uint256 private _rareLimit;
uint256 private _commonPrice;
uint256 private _rarePrice;
uint256 private _rarePriceIncrease;
mapping(address => uint256) private _commonIssued;
mapping(address => uint256) private _rareIssued;
IPotions private _potion;
IBenefits private _benefits;
mapping(address => uint256) private _commonLimits;
mapping(address => uint256) private _rareLimits;
mapping(uint256 => bool) private _rare;
string private constant INCORRECT_PRICE = "MysteryBox: incorrect price";
string private constant SOLD_OUT = "MysteryBox: sold out";
string private constant NO_MORE_RARE =
"MysteryBox: no more rare tokens allowed for user";
string private constant NO_MORE_COMMON =
"MysteryBox: no more common tokens allowed for user";
string private constant SOLD_OUT_RARE = "MysteryBox: sold out rare tokens";
string private constant SOLD_OUT_COMMON =
"MysteryBox: sold out common tokens";
string private constant WRONG_OWNER = "MysteryBox: wrong owner";
string private constant WRONG_ID = "MysteryBox: wrong id";
string private constant SAME_VALUE = "MysteryBox: same value";
string private constant ZERO_ADDRESS = "MysteryBox: zero address";
string private constant BASE_META_HASH =
"ipfs://QmVUH44vewH4iF93gSMez3qB4dUxc7DowXPztiG3uRXFWS/";
/// @notice validate the id
modifier correctId(uint256 id_) {
}
/**
@notice Constructor
@param name_ The name
@param symbol_ The symbol
@param rights_ The rights address
@param potion_ The potion address
@param benefits_ The benefits address
@param commonLimit_ The maximum number of the common potions saled for one account
@param rareLimit_ The maximum number of the rare potions saled for one account
@param commonPrice_ The price of the common potion
@param rarePrice_ The price of the rare potion
@param rarePriceIncrease_ The increase of the price for each bought rare box
*/
constructor(
string memory name_,
string memory symbol_,
address rights_,
address potion_,
address benefits_,
uint256 commonLimit_,
uint256 rareLimit_,
uint256 commonPrice_,
uint256 rarePrice_,
uint256 rarePriceIncrease_
) Guard() ERC721(name_, symbol_) GuardExtension(rights_) {
}
/**
@notice Get a total amount of issued tokens
@return The number of tokens minted
*/
function total() external view override returns (uint256) {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setCommonLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the price of the common potions for the account
@param value_ New price
*/
function setCommonPrice(uint256 value_) external override haveRights {
}
/**
@notice Set new address of Potion contract
@param value_ New address value
*/
function setPotion(address value_) external haveRights {
}
/**
@notice Set new address of Benefits contract
@param value_ New address value
*/
function setBenefits(address value_) external haveRights {
require(<FILL_ME>)
require(value_ != address(0), ZERO_ADDRESS);
_benefits = IBenefits(value_);
}
/**
@notice Set the maximum amount of the rare potions saled for one account
@param value_ New amount
*/
function setRareLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setRarePrice(uint256 value_) external override haveRights {
}
/**
@notice Set the increase of the rare price
@param value_ New amount
*/
function setRarePriceIncrease(uint256 value_) external override haveRights {
}
/**
@notice Get the current rare price
@return Current rare price level
*/
function getRarePrice() external view override returns (uint256) {
}
/**
@notice Get the amount of the tokens account can buy
@return The two uint's - amount of the common potions and amount of the rare potions
*/
function getIssued(address account_)
external
view
override
returns (uint256, uint256)
{
}
/**
@notice Create the packed id with rare or not (admin only)
@param target_ The box owner
@param rare_ The rarity flag
@return The new box id
*/
function create(address target_, bool rare_)
external
override
haveRights
returns (uint256)
{
}
function _create(address account_, uint8 level_) private returns (uint256) {
}
/**
@notice Get the rarity of the box
@param tokenId_ The id of the token
@return The rarity flag
*/
function rarity(uint256 tokenId_)
external
view
override
correctId(tokenId_)
returns (bool)
{
}
/**
@notice Deposit the funds (payable function)
*/
function deposit() external payable override haveRights {}
/**
@notice Receive the funds and give the box with rarity according to the amount of funds transferred
Look the event to get the ID (receive functions cannot return values)
*/
receive() external payable {
}
function _create(
address account_,
uint8 level_,
address benTarget_,
uint256 benId_,
bool benIsFound_,
uint256 newTokenId_
) private returns (uint256) {
}
/**
@notice Open the packed box
@param id_ The box id
@return The new potion id
*/
function open(uint256 id_)
external
override
correctId(id_)
returns (uint256)
{
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 id_)
public
view
override(ERC721, IERC721Metadata)
correctId(id_)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721, ERC2981)
returns (bool)
{
}
}
| address(_benefits)!=value_,SAME_VALUE | 102,809 | address(_benefits)!=value_ |
SOLD_OUT_RARE | // SPDX-License-Identifier: PROPRIERTARY
// Author: Ilya A. Shlyakhovoy
// Email: [email protected]
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IPotions.sol";
import "./interfaces/IBenefits.sol";
import "./interfaces/IMysteryBox.sol";
import "../utils/Claimable.sol";
import "../utils/EIP2981.sol";
import "../utils/GuardExtension.sol";
import {
OperatorFiltererERC721,
ERC721
} from "../utils/OperatorFiltererERC721.sol";
contract MysteryBox is
GuardExtension,
OperatorFiltererERC721,
EIP2981,
Claimable,
IMysteryBox
{
using Address for address;
using Address for address payable;
using Strings for uint256;
uint256 private _tokenIds;
uint256 private _total;
uint256 private _commonLimit;
uint256 private _rareLimit;
uint256 private _commonPrice;
uint256 private _rarePrice;
uint256 private _rarePriceIncrease;
mapping(address => uint256) private _commonIssued;
mapping(address => uint256) private _rareIssued;
IPotions private _potion;
IBenefits private _benefits;
mapping(address => uint256) private _commonLimits;
mapping(address => uint256) private _rareLimits;
mapping(uint256 => bool) private _rare;
string private constant INCORRECT_PRICE = "MysteryBox: incorrect price";
string private constant SOLD_OUT = "MysteryBox: sold out";
string private constant NO_MORE_RARE =
"MysteryBox: no more rare tokens allowed for user";
string private constant NO_MORE_COMMON =
"MysteryBox: no more common tokens allowed for user";
string private constant SOLD_OUT_RARE = "MysteryBox: sold out rare tokens";
string private constant SOLD_OUT_COMMON =
"MysteryBox: sold out common tokens";
string private constant WRONG_OWNER = "MysteryBox: wrong owner";
string private constant WRONG_ID = "MysteryBox: wrong id";
string private constant SAME_VALUE = "MysteryBox: same value";
string private constant ZERO_ADDRESS = "MysteryBox: zero address";
string private constant BASE_META_HASH =
"ipfs://QmVUH44vewH4iF93gSMez3qB4dUxc7DowXPztiG3uRXFWS/";
/// @notice validate the id
modifier correctId(uint256 id_) {
}
/**
@notice Constructor
@param name_ The name
@param symbol_ The symbol
@param rights_ The rights address
@param potion_ The potion address
@param benefits_ The benefits address
@param commonLimit_ The maximum number of the common potions saled for one account
@param rareLimit_ The maximum number of the rare potions saled for one account
@param commonPrice_ The price of the common potion
@param rarePrice_ The price of the rare potion
@param rarePriceIncrease_ The increase of the price for each bought rare box
*/
constructor(
string memory name_,
string memory symbol_,
address rights_,
address potion_,
address benefits_,
uint256 commonLimit_,
uint256 rareLimit_,
uint256 commonPrice_,
uint256 rarePrice_,
uint256 rarePriceIncrease_
) Guard() ERC721(name_, symbol_) GuardExtension(rights_) {
}
/**
@notice Get a total amount of issued tokens
@return The number of tokens minted
*/
function total() external view override returns (uint256) {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setCommonLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the price of the common potions for the account
@param value_ New price
*/
function setCommonPrice(uint256 value_) external override haveRights {
}
/**
@notice Set new address of Potion contract
@param value_ New address value
*/
function setPotion(address value_) external haveRights {
}
/**
@notice Set new address of Benefits contract
@param value_ New address value
*/
function setBenefits(address value_) external haveRights {
}
/**
@notice Set the maximum amount of the rare potions saled for one account
@param value_ New amount
*/
function setRareLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setRarePrice(uint256 value_) external override haveRights {
}
/**
@notice Set the increase of the rare price
@param value_ New amount
*/
function setRarePriceIncrease(uint256 value_) external override haveRights {
}
/**
@notice Get the current rare price
@return Current rare price level
*/
function getRarePrice() external view override returns (uint256) {
}
/**
@notice Get the amount of the tokens account can buy
@return The two uint's - amount of the common potions and amount of the rare potions
*/
function getIssued(address account_)
external
view
override
returns (uint256, uint256)
{
}
/**
@notice Create the packed id with rare or not (admin only)
@param target_ The box owner
@param rare_ The rarity flag
@return The new box id
*/
function create(address target_, bool rare_)
external
override
haveRights
returns (uint256)
{
}
function _create(address account_, uint8 level_) private returns (uint256) {
}
/**
@notice Get the rarity of the box
@param tokenId_ The id of the token
@return The rarity flag
*/
function rarity(uint256 tokenId_)
external
view
override
correctId(tokenId_)
returns (bool)
{
}
/**
@notice Deposit the funds (payable function)
*/
function deposit() external payable override haveRights {}
/**
@notice Receive the funds and give the box with rarity according to the amount of funds transferred
Look the event to get the ID (receive functions cannot return values)
*/
receive() external payable {
}
function _create(
address account_,
uint8 level_,
address benTarget_,
uint256 benId_,
bool benIsFound_,
uint256 newTokenId_
) private returns (uint256) {
bool isRare = level_ > 0;
if (isRare && newTokenId_ != 1) {
_rarePrice = _rarePrice + _rarePriceIncrease;
}
IBenefits benefits = _benefits;
if (isRare) {
require(_rareLimit > _rareIssued[account_], NO_MORE_RARE);
require(<FILL_ME>)
_rareIssued[account_] = _rareIssued[account_] + 1;
} else {
require(_potion.decreaseAmount(false), SOLD_OUT_COMMON);
_commonIssued[account_] = _commonIssued[account_] + 1;
}
uint256 newId = newTokenId_ == 0 ? _tokenIds : newTokenId_;
if (newTokenId_ == 0) {
do {
newId = newId + 1;
} while (benefits.denied(newId));
_tokenIds = newId;
}
_rare[newId] = isRare;
_mint(account_, newId);
if (benIsFound_) {
benefits.set(benTarget_, benId_);
}
emit Created(account_, newId, isRare);
_total += 1;
return newId;
}
/**
@notice Open the packed box
@param id_ The box id
@return The new potion id
*/
function open(uint256 id_)
external
override
correctId(id_)
returns (uint256)
{
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 id_)
public
view
override(ERC721, IERC721Metadata)
correctId(id_)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721, ERC2981)
returns (bool)
{
}
}
| _potion.decreaseAmount(true),SOLD_OUT_RARE | 102,809 | _potion.decreaseAmount(true) |
SOLD_OUT_COMMON | // SPDX-License-Identifier: PROPRIERTARY
// Author: Ilya A. Shlyakhovoy
// Email: [email protected]
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IPotions.sol";
import "./interfaces/IBenefits.sol";
import "./interfaces/IMysteryBox.sol";
import "../utils/Claimable.sol";
import "../utils/EIP2981.sol";
import "../utils/GuardExtension.sol";
import {
OperatorFiltererERC721,
ERC721
} from "../utils/OperatorFiltererERC721.sol";
contract MysteryBox is
GuardExtension,
OperatorFiltererERC721,
EIP2981,
Claimable,
IMysteryBox
{
using Address for address;
using Address for address payable;
using Strings for uint256;
uint256 private _tokenIds;
uint256 private _total;
uint256 private _commonLimit;
uint256 private _rareLimit;
uint256 private _commonPrice;
uint256 private _rarePrice;
uint256 private _rarePriceIncrease;
mapping(address => uint256) private _commonIssued;
mapping(address => uint256) private _rareIssued;
IPotions private _potion;
IBenefits private _benefits;
mapping(address => uint256) private _commonLimits;
mapping(address => uint256) private _rareLimits;
mapping(uint256 => bool) private _rare;
string private constant INCORRECT_PRICE = "MysteryBox: incorrect price";
string private constant SOLD_OUT = "MysteryBox: sold out";
string private constant NO_MORE_RARE =
"MysteryBox: no more rare tokens allowed for user";
string private constant NO_MORE_COMMON =
"MysteryBox: no more common tokens allowed for user";
string private constant SOLD_OUT_RARE = "MysteryBox: sold out rare tokens";
string private constant SOLD_OUT_COMMON =
"MysteryBox: sold out common tokens";
string private constant WRONG_OWNER = "MysteryBox: wrong owner";
string private constant WRONG_ID = "MysteryBox: wrong id";
string private constant SAME_VALUE = "MysteryBox: same value";
string private constant ZERO_ADDRESS = "MysteryBox: zero address";
string private constant BASE_META_HASH =
"ipfs://QmVUH44vewH4iF93gSMez3qB4dUxc7DowXPztiG3uRXFWS/";
/// @notice validate the id
modifier correctId(uint256 id_) {
}
/**
@notice Constructor
@param name_ The name
@param symbol_ The symbol
@param rights_ The rights address
@param potion_ The potion address
@param benefits_ The benefits address
@param commonLimit_ The maximum number of the common potions saled for one account
@param rareLimit_ The maximum number of the rare potions saled for one account
@param commonPrice_ The price of the common potion
@param rarePrice_ The price of the rare potion
@param rarePriceIncrease_ The increase of the price for each bought rare box
*/
constructor(
string memory name_,
string memory symbol_,
address rights_,
address potion_,
address benefits_,
uint256 commonLimit_,
uint256 rareLimit_,
uint256 commonPrice_,
uint256 rarePrice_,
uint256 rarePriceIncrease_
) Guard() ERC721(name_, symbol_) GuardExtension(rights_) {
}
/**
@notice Get a total amount of issued tokens
@return The number of tokens minted
*/
function total() external view override returns (uint256) {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setCommonLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the price of the common potions for the account
@param value_ New price
*/
function setCommonPrice(uint256 value_) external override haveRights {
}
/**
@notice Set new address of Potion contract
@param value_ New address value
*/
function setPotion(address value_) external haveRights {
}
/**
@notice Set new address of Benefits contract
@param value_ New address value
*/
function setBenefits(address value_) external haveRights {
}
/**
@notice Set the maximum amount of the rare potions saled for one account
@param value_ New amount
*/
function setRareLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setRarePrice(uint256 value_) external override haveRights {
}
/**
@notice Set the increase of the rare price
@param value_ New amount
*/
function setRarePriceIncrease(uint256 value_) external override haveRights {
}
/**
@notice Get the current rare price
@return Current rare price level
*/
function getRarePrice() external view override returns (uint256) {
}
/**
@notice Get the amount of the tokens account can buy
@return The two uint's - amount of the common potions and amount of the rare potions
*/
function getIssued(address account_)
external
view
override
returns (uint256, uint256)
{
}
/**
@notice Create the packed id with rare or not (admin only)
@param target_ The box owner
@param rare_ The rarity flag
@return The new box id
*/
function create(address target_, bool rare_)
external
override
haveRights
returns (uint256)
{
}
function _create(address account_, uint8 level_) private returns (uint256) {
}
/**
@notice Get the rarity of the box
@param tokenId_ The id of the token
@return The rarity flag
*/
function rarity(uint256 tokenId_)
external
view
override
correctId(tokenId_)
returns (bool)
{
}
/**
@notice Deposit the funds (payable function)
*/
function deposit() external payable override haveRights {}
/**
@notice Receive the funds and give the box with rarity according to the amount of funds transferred
Look the event to get the ID (receive functions cannot return values)
*/
receive() external payable {
}
function _create(
address account_,
uint8 level_,
address benTarget_,
uint256 benId_,
bool benIsFound_,
uint256 newTokenId_
) private returns (uint256) {
bool isRare = level_ > 0;
if (isRare && newTokenId_ != 1) {
_rarePrice = _rarePrice + _rarePriceIncrease;
}
IBenefits benefits = _benefits;
if (isRare) {
require(_rareLimit > _rareIssued[account_], NO_MORE_RARE);
require(_potion.decreaseAmount(true), SOLD_OUT_RARE);
_rareIssued[account_] = _rareIssued[account_] + 1;
} else {
require(<FILL_ME>)
_commonIssued[account_] = _commonIssued[account_] + 1;
}
uint256 newId = newTokenId_ == 0 ? _tokenIds : newTokenId_;
if (newTokenId_ == 0) {
do {
newId = newId + 1;
} while (benefits.denied(newId));
_tokenIds = newId;
}
_rare[newId] = isRare;
_mint(account_, newId);
if (benIsFound_) {
benefits.set(benTarget_, benId_);
}
emit Created(account_, newId, isRare);
_total += 1;
return newId;
}
/**
@notice Open the packed box
@param id_ The box id
@return The new potion id
*/
function open(uint256 id_)
external
override
correctId(id_)
returns (uint256)
{
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 id_)
public
view
override(ERC721, IERC721Metadata)
correctId(id_)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721, ERC2981)
returns (bool)
{
}
}
| _potion.decreaseAmount(false),SOLD_OUT_COMMON | 102,809 | _potion.decreaseAmount(false) |
WRONG_OWNER | // SPDX-License-Identifier: PROPRIERTARY
// Author: Ilya A. Shlyakhovoy
// Email: [email protected]
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/IPotions.sol";
import "./interfaces/IBenefits.sol";
import "./interfaces/IMysteryBox.sol";
import "../utils/Claimable.sol";
import "../utils/EIP2981.sol";
import "../utils/GuardExtension.sol";
import {
OperatorFiltererERC721,
ERC721
} from "../utils/OperatorFiltererERC721.sol";
contract MysteryBox is
GuardExtension,
OperatorFiltererERC721,
EIP2981,
Claimable,
IMysteryBox
{
using Address for address;
using Address for address payable;
using Strings for uint256;
uint256 private _tokenIds;
uint256 private _total;
uint256 private _commonLimit;
uint256 private _rareLimit;
uint256 private _commonPrice;
uint256 private _rarePrice;
uint256 private _rarePriceIncrease;
mapping(address => uint256) private _commonIssued;
mapping(address => uint256) private _rareIssued;
IPotions private _potion;
IBenefits private _benefits;
mapping(address => uint256) private _commonLimits;
mapping(address => uint256) private _rareLimits;
mapping(uint256 => bool) private _rare;
string private constant INCORRECT_PRICE = "MysteryBox: incorrect price";
string private constant SOLD_OUT = "MysteryBox: sold out";
string private constant NO_MORE_RARE =
"MysteryBox: no more rare tokens allowed for user";
string private constant NO_MORE_COMMON =
"MysteryBox: no more common tokens allowed for user";
string private constant SOLD_OUT_RARE = "MysteryBox: sold out rare tokens";
string private constant SOLD_OUT_COMMON =
"MysteryBox: sold out common tokens";
string private constant WRONG_OWNER = "MysteryBox: wrong owner";
string private constant WRONG_ID = "MysteryBox: wrong id";
string private constant SAME_VALUE = "MysteryBox: same value";
string private constant ZERO_ADDRESS = "MysteryBox: zero address";
string private constant BASE_META_HASH =
"ipfs://QmVUH44vewH4iF93gSMez3qB4dUxc7DowXPztiG3uRXFWS/";
/// @notice validate the id
modifier correctId(uint256 id_) {
}
/**
@notice Constructor
@param name_ The name
@param symbol_ The symbol
@param rights_ The rights address
@param potion_ The potion address
@param benefits_ The benefits address
@param commonLimit_ The maximum number of the common potions saled for one account
@param rareLimit_ The maximum number of the rare potions saled for one account
@param commonPrice_ The price of the common potion
@param rarePrice_ The price of the rare potion
@param rarePriceIncrease_ The increase of the price for each bought rare box
*/
constructor(
string memory name_,
string memory symbol_,
address rights_,
address potion_,
address benefits_,
uint256 commonLimit_,
uint256 rareLimit_,
uint256 commonPrice_,
uint256 rarePrice_,
uint256 rarePriceIncrease_
) Guard() ERC721(name_, symbol_) GuardExtension(rights_) {
}
/**
@notice Get a total amount of issued tokens
@return The number of tokens minted
*/
function total() external view override returns (uint256) {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setCommonLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the price of the common potions for the account
@param value_ New price
*/
function setCommonPrice(uint256 value_) external override haveRights {
}
/**
@notice Set new address of Potion contract
@param value_ New address value
*/
function setPotion(address value_) external haveRights {
}
/**
@notice Set new address of Benefits contract
@param value_ New address value
*/
function setBenefits(address value_) external haveRights {
}
/**
@notice Set the maximum amount of the rare potions saled for one account
@param value_ New amount
*/
function setRareLimit(uint256 value_) external override haveRights {
}
/**
@notice Set the maximum amount of the common potions saled for one account
@param value_ New amount
*/
function setRarePrice(uint256 value_) external override haveRights {
}
/**
@notice Set the increase of the rare price
@param value_ New amount
*/
function setRarePriceIncrease(uint256 value_) external override haveRights {
}
/**
@notice Get the current rare price
@return Current rare price level
*/
function getRarePrice() external view override returns (uint256) {
}
/**
@notice Get the amount of the tokens account can buy
@return The two uint's - amount of the common potions and amount of the rare potions
*/
function getIssued(address account_)
external
view
override
returns (uint256, uint256)
{
}
/**
@notice Create the packed id with rare or not (admin only)
@param target_ The box owner
@param rare_ The rarity flag
@return The new box id
*/
function create(address target_, bool rare_)
external
override
haveRights
returns (uint256)
{
}
function _create(address account_, uint8 level_) private returns (uint256) {
}
/**
@notice Get the rarity of the box
@param tokenId_ The id of the token
@return The rarity flag
*/
function rarity(uint256 tokenId_)
external
view
override
correctId(tokenId_)
returns (bool)
{
}
/**
@notice Deposit the funds (payable function)
*/
function deposit() external payable override haveRights {}
/**
@notice Receive the funds and give the box with rarity according to the amount of funds transferred
Look the event to get the ID (receive functions cannot return values)
*/
receive() external payable {
}
function _create(
address account_,
uint8 level_,
address benTarget_,
uint256 benId_,
bool benIsFound_,
uint256 newTokenId_
) private returns (uint256) {
}
/**
@notice Open the packed box
@param id_ The box id
@return The new potion id
*/
function open(uint256 id_)
external
override
correctId(id_)
returns (uint256)
{
require(<FILL_ME>)
uint256 newId = _potion.create(msg.sender, _rare[id_], id_);
delete _rare[id_];
_burn(id_);
emit Opened(msg.sender, newId);
return newId;
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 id_)
public
view
override(ERC721, IERC721Metadata)
correctId(id_)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, ERC721, ERC2981)
returns (bool)
{
}
}
| ownerOf(id_)==msg.sender,WRONG_OWNER | 102,809 | ownerOf(id_)==msg.sender |
null | /*
📄Whitepaper: https://0xcbot.gitbook.io/0xcbot-whitepaper/
🌐Website: https://zeroxcbot.com/
🌐Portal: https://t.me/zeroxcbotPortal
🌐Twitter: https://twitter.com/ZeroxcbotErc
*/
// SPDX-License-Identifier: Unlicensed
pragma solidity 0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom( address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newOwner) public onlyOwner {
}
function _transferOwnership(address newOwner) internal {
}
function renounceOwnership() public virtual onlyOwner {
}
}
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);
}
contract OXCBOT is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _walletExcluded;
uint256 private constant MAX = ~uint256(0);
uint8 private constant _decimals = 18;
uint256 private constant _totalSupply = 10**7 * 10**_decimals;
uint256 private constant minSwap = 4000 * 10**_decimals;
uint256 private constant onePercent = 100000 * 10**_decimals;
uint256 public maxTxAmount = onePercent * 2;
uint256 private launchBlock;
uint256 private buyValue = 0;
uint256 private _tax;
uint256 public buyTax = 25;
uint256 public sellTax = 50;
string private constant _name = "0XCBOT";
string private constant _symbol = "0xC";
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
address payable public canteen;
bool private launch = false;
constructor(address[] memory wallets) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)public override returns (bool){
}
function allowance(address owner, address spender) public view override returns (uint256){
}
function approve(address spender, uint256 amount) public override returns (bool){
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function enableTrading() external onlyOwner {
}
function addExcludedWallet(address wallet) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function changeTax(uint256 newBuyTax, uint256 newSellTax) external onlyOwner {
}
function theBot(uint256 newBuyValue) external onlyOwner {
}
function _tokenTransfer(address from, address to, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function manualSendBalance() external {
require(<FILL_ME>)
uint256 contractETHBalance = address(this).balance;
canteen.transfer(contractETHBalance);
uint256 contractBalance = balanceOf(address(this));
canteen.transfer(contractBalance);
}
function manualSwapTokens() external {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
receive() external payable {}
}
| _msgSender()==canteen | 102,834 | _msgSender()==canteen |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.