comment
stringlengths 1
211
β | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Reached limit of minting" | pragma solidity ^0.8.13;
contract Dogs is ERC721A, ERC2981, DefaultOperatorFilterer, Ownable {
using Strings for uint256;
string public uriPrefix = "ipfs://";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.002 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmountPerTx = 50;
uint256 public nftsPeerAddress = 1000;
bool public paused = false;
bool public revealed = true;
mapping(address => uint256) public addressNfts;
constructor() ERC721A("Dogs WTF", "Dogs") {
}
modifier mintCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
require(msg.value >= cost * _mintAmount, "Insufficient funds!");
require(totalSupply() + _mintAmount <= maxSupply, "Not enough left to mint all your requests");
require(<FILL_ME>)
_safeMint(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address[] memory _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setNftsPeerAddress(uint256 _nftsPeerAddress) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) {
}
function approve(address operator, uint256 tokenId)
public
override(ERC721A)
onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from, address to, uint256 tokenId)
public
override(ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId)
public
override(ERC721A)
onlyAllowedOperator(from)
{
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(ERC721A)
onlyAllowedOperator(from)
{
}
}
| addressNfts[msg.sender]+_mintAmount<=nftsPeerAddress,"Reached limit of minting" | 504,447 | addressNfts[msg.sender]+_mintAmount<=nftsPeerAddress |
"cannotDonate" | pragma solidity ^0.8.0;
import "IERC20.sol";
import "Math.sol";
import "SafeERC20.sol";
interface IStrategy {
function vault() external returns (address);
}
contract Donator {
using SafeERC20 for IERC20;
event Donated(address strategy, uint256 amount, uint256 period);
uint internal constant WEEK = 60 * 60 * 24 * 7;
address internal constant YCRV = 0xFCc5c47bE19d06BF83eB04298b026F81069ff65b;
address public governance;
address public management;
address public strategy;
address public pendingGovernance;
uint256 public donateAmount;
uint256 public lastDonatePeriod;
bool public donationsPaused;
constructor() {
}
/// @notice check if enough time has elapsed since our last donation
function canDonate() public view returns (bool) {
}
function donate() external {
require(<FILL_ME>)
uint256 balance = IERC20(YCRV).balanceOf(address(this));
require(balance > 0, "nothingToDonate");
uint amountDonated = Math.min(balance, donateAmount);
address _strategy = strategy;
IERC20(YCRV).transfer(_strategy, amountDonated);
uint currentPeriod = block.timestamp / WEEK * WEEK;
lastDonatePeriod = currentPeriod;
emit Donated(_strategy, amountDonated, currentPeriod);
}
function setDonateAmount(uint256 _donateAmount) public {
}
function setPaused(bool _paused) public {
}
function setGovernance(address _governance) external {
}
function setManagement(address _management) external {
}
function setStrategy(address _strategy) external {
}
function acceptGovernance() external {
}
/// @notice sweep function in case anyone sends random tokens here or we need to rescue yvBOOST
function sweep(address _token) external {
}
}
| canDonate(),"cannotDonate" | 504,553 | canDonate() |
"invalidStrategy" | pragma solidity ^0.8.0;
import "IERC20.sol";
import "Math.sol";
import "SafeERC20.sol";
interface IStrategy {
function vault() external returns (address);
}
contract Donator {
using SafeERC20 for IERC20;
event Donated(address strategy, uint256 amount, uint256 period);
uint internal constant WEEK = 60 * 60 * 24 * 7;
address internal constant YCRV = 0xFCc5c47bE19d06BF83eB04298b026F81069ff65b;
address public governance;
address public management;
address public strategy;
address public pendingGovernance;
uint256 public donateAmount;
uint256 public lastDonatePeriod;
bool public donationsPaused;
constructor() {
}
/// @notice check if enough time has elapsed since our last donation
function canDonate() public view returns (bool) {
}
function donate() external {
}
function setDonateAmount(uint256 _donateAmount) public {
}
function setPaused(bool _paused) public {
}
function setGovernance(address _governance) external {
}
function setManagement(address _management) external {
}
function setStrategy(address _strategy) external {
require(msg.sender == governance, "!authorized");
require(<FILL_ME>)
strategy = _strategy;
}
function acceptGovernance() external {
}
/// @notice sweep function in case anyone sends random tokens here or we need to rescue yvBOOST
function sweep(address _token) external {
}
}
| IStrategy(_strategy).vault()!=address(0),"invalidStrategy" | 504,553 | IStrategy(_strategy).vault()!=address(0) |
"not a royalty payee" | // SPDX-License-Identifier: UNLICENSE
// Creator: 0xYeety; Based Pixel Labs/Yeety Labs; 1 yeet = 1 yeet; 1 cope = 1 cope
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract RoyaltyReceiver is Ownable {
uint256 numPayees;
mapping(uint256 => address) private indexer;
mapping(address => uint256) public royaltySplit;
mapping(address => uint256) public balances;
string public name;
/**
* @dev Throws if called by any account other than a royalty receiver/payee.
*/
modifier onlyPayee() {
}
/**
* @dev Throws if the sender is not on the royalty receiver/payee list.
*/
function _isPayee() internal view virtual {
require(<FILL_ME>)
}
constructor(string memory _name, address[] memory payees, uint256[] memory percentages) {
}
receive() external payable {
}
function withdraw() external onlyPayee() {
}
function withdrawTokens(address tokenAddress) external onlyOwner() {
}
function messageSender() public view returns (address) {
}
}
| royaltySplit[address(msg.sender)]>0,"not a royalty payee" | 504,657 | royaltySplit[address(msg.sender)]>0 |
"Metropolis 888: invalid merkle proof" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
contract Metropolis888 is ERC721A, Ownable {
using Strings for uint256;
string private _uriPrefix;
string private _uriSuffix;
uint256 public maxSupply;
uint256 public presaleSupply;
uint256 public maxMintAmountPerAddress;
uint256 public maxMintAmountPerAddressForVip;
bytes32 private _presaleMerkleRoot;
bytes32 private _vipAddressesMerkleRoot;
enum SaleState { PAUSED, PRESALE, PUBLIC_SALE }
mapping(address => uint256) public helpers;
string private contractMetadataURI;
SaleState public saleState;
event SaleStateChanged(SaleState indexed oldSaleState, SaleState indexed newSaleState);
event UriPrefixUpdated(string indexed oldURIprefix, string indexed newURIprefix);
event UriSuffixUpdated(string indexed oldURIsuffix, string indexed newURIsuffix);
event MaxSupplyUpdated(uint256 indexed oldMaxSupply, uint256 indexed newMaxSupply);
event PresaleSupplyUpdated(uint256 indexed oldPresaleSupply, uint256 indexed newPresaleSupply);
event MaxMintAmountPerAddressUpdated(uint256 indexed oldMaxMintAmountPerAddress, uint256 indexed newMaxMintAmountPerAddress);
event MaxMintAmountPerAddressForVipUpdated(uint256 indexed oldMaxMintAmountPerAddressForVip, uint256 indexed newMaxMintAmountPerAddressForVip);
event PresaleMerkleRootUpdated(bytes32 indexed oldPresaleMerkleRoot, bytes32 indexed newPresaleMerkleRoot);
event VipAddressesMerkleRootUpdated(bytes32 indexed oldVipAddressesMerkleRoot, bytes32 indexed newVipAddressesMerkleRoot);
constructor(string memory initUriPrefix, bytes32 initPresaleMerkleRoot, bytes32 initVipAddressesMerkleRoot) ERC721A("Metropolis 888", "M888") {
}
function mint(uint256 amount, bytes32[] calldata vipMerkleProof) external payable {
}
function presaleMint(uint256 amount, bytes32[] calldata vipMerkleProof, bytes32[] calldata presaleMerkleProof) external payable {
require(tx.origin == _msgSender(), "Metropolis 888: contract denied");
require(saleState == SaleState.PRESALE, "Metropolis 888: minting is not in presale");
require(amount > 0 && _numberMinted(_msgSender()) + amount <= _maxMintAmount(_msgSender(), vipMerkleProof), "Metropolis 888: invalid mint amount");
require(<FILL_ME>)
uint256 newSupply = _totalMinted() + amount;
require(newSupply <= presaleSupply, "Metropolis 888: presale token supply exceeded");
_safeMint(_msgSender(), amount);
}
function helperMint() external payable {
}
function contractURI() public view returns (string memory) {
}
function setContractMetadataURI(string memory _contractMetadataURI) external onlyOwner {
}
function addHelper(address _address, uint256 _amount) external onlyOwner {
}
function addMultipleHelpers(address[] calldata _addresses, uint256[] calldata _amounts) external onlyOwner {
}
function removeHelper(address _address) external onlyOwner {
}
function isHelper(address _address) public view returns(uint256) {
}
function setSaleState(SaleState newSaleState) external onlyOwner {
}
function tokenURI(uint256 tokenId) public view override returns(string memory) {
}
function setUriPrefix(string memory newPrefix) external onlyOwner {
}
function setUriSuffix(string memory newSuffix) external onlyOwner {
}
function setMaxSupply(uint256 newMaxSupply) external onlyOwner {
}
function setPresaleSupply(uint256 newPresaleSupply) external onlyOwner {
}
function setMaxMintAmountPerAddress(uint256 newMaxMintAmountPerAddress) external onlyOwner {
}
function setMaxMintAmountPerAddressForVip(uint256 newMaxMintAmountPerAddressForVip) external onlyOwner {
}
function setPresaleMerkleRoot(bytes32 newPresaleMerkleRoot) external onlyOwner {
}
function setVipAddressesMerkleRoot(bytes32 newVipAddressesMerkleRoot) external onlyOwner {
}
function _baseURI() internal view override returns(string memory) {
}
function _startTokenId() internal pure override returns(uint256) {
}
function _maxMintAmount(address account, bytes32[] calldata merkleProof) internal view returns(uint256) {
}
function _merkleProof(address account, bytes32[] calldata merkleProof, bytes32 merkleRoot) internal pure returns(bool) {
}
}
| _merkleProof(_msgSender(),presaleMerkleProof,_presaleMerkleRoot),"Metropolis 888: invalid merkle proof" | 504,975 | _merkleProof(_msgSender(),presaleMerkleProof,_presaleMerkleRoot) |
"Not enough" | pragma solidity ^0.8.7;
contract Doblin is ERC721, Ownable {
uint256 public TOKEN_PRICE = 0 ether;
uint256 public totalTokens;
uint256 public MAX_TOKENS_PER_WALLET = 1;
uint256 public MAX_SUPPLY = 5000;
address teamWallet = 0xa8DE1e8bb69e528746C0Eb7050C18Cb937430cDf;
mapping(address => uint256) public walletMints;
string private BASE_URI = "https://doblin.io/api/?token_id=";
constructor() ERC721("Doblin", "DOB") {}
function mint(uint16 numberOfTokens) external payable {
require(<FILL_ME>)
require(walletMints[msg.sender] + numberOfTokens <= MAX_TOKENS_PER_WALLET, "Max 1");
require(TOKEN_PRICE * numberOfTokens <= msg.value, 'missing eth');
for(uint256 i = 1; i <= numberOfTokens; i+=1) {
_safeMint(msg.sender, totalTokens+i);
}
totalTokens += numberOfTokens;
walletMints[msg.sender] += numberOfTokens;
}
function airdrop(uint16 numberOfTokens, address userAddress) external onlyOwner {
}
function setTokenPrice(uint256 price) external onlyOwner {
}
function setMaxSupply(uint256 maxTokens) external onlyOwner {
}
function setMaxPerWallet(uint256 maxTokens) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function tokensOfOwner(address _owner) external view returns(uint[] memory ) {
}
function totalSupply() public view virtual returns(uint256){
}
}
| totalTokens+numberOfTokens<=MAX_SUPPLY,"Not enough" | 505,075 | totalTokens+numberOfTokens<=MAX_SUPPLY |
"Max 1" | pragma solidity ^0.8.7;
contract Doblin is ERC721, Ownable {
uint256 public TOKEN_PRICE = 0 ether;
uint256 public totalTokens;
uint256 public MAX_TOKENS_PER_WALLET = 1;
uint256 public MAX_SUPPLY = 5000;
address teamWallet = 0xa8DE1e8bb69e528746C0Eb7050C18Cb937430cDf;
mapping(address => uint256) public walletMints;
string private BASE_URI = "https://doblin.io/api/?token_id=";
constructor() ERC721("Doblin", "DOB") {}
function mint(uint16 numberOfTokens) external payable {
require(totalTokens + numberOfTokens <= MAX_SUPPLY, "Not enough");
require(<FILL_ME>)
require(TOKEN_PRICE * numberOfTokens <= msg.value, 'missing eth');
for(uint256 i = 1; i <= numberOfTokens; i+=1) {
_safeMint(msg.sender, totalTokens+i);
}
totalTokens += numberOfTokens;
walletMints[msg.sender] += numberOfTokens;
}
function airdrop(uint16 numberOfTokens, address userAddress) external onlyOwner {
}
function setTokenPrice(uint256 price) external onlyOwner {
}
function setMaxSupply(uint256 maxTokens) external onlyOwner {
}
function setMaxPerWallet(uint256 maxTokens) external onlyOwner {
}
function setBaseURI(string memory baseURI) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function withdraw() public onlyOwner {
}
function tokensOfOwner(address _owner) external view returns(uint[] memory ) {
}
function totalSupply() public view virtual returns(uint256){
}
}
| walletMints[msg.sender]+numberOfTokens<=MAX_TOKENS_PER_WALLET,"Max 1" | 505,075 | walletMints[msg.sender]+numberOfTokens<=MAX_TOKENS_PER_WALLET |
"Presale Paused" | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
Website: https://www.gptapes.xyz/
Twitter: https://twitter.com/gptapesnft
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
address private signerAddress = 0xF84f0303565De612108aC24593DeffBF124A93ef;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.006 ether;
uint256 public preSalePrice = 0.004 ether;
uint256 public preSaleMaxMint = 10;
uint64 public WALLET_MAX = 50;
uint256 public maxFreeMint = 1;
uint256 public maxFreePreMint = 1;
string private _baseTokenURI = "ipfs://bafybeiefapxgpfg5g3e5h3ivzjsley5aikqqpzxcl2x2li7uja3w3ncnf4/";
string private baseExtension = ".json";
bool public pausedPresale = false;
bool public pausedSale = true;
event Minted(address indexed receiver, uint256 quantity);
mapping(address => uint256) private _freeMintedCount;
mapping(address => uint256) private _freePreMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Verify signature
function verifyAddressSigner(bytes memory signature) private
view returns (bool) {
}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable {
}
// Presale mints
function preSaleMint(uint64 quantity, bytes memory signature) external payable {
require(<FILL_ME>)
require((_totalMinted()+ quantity) <= maxSupply, "Supply exceeded");
require((_numberMinted(msg.sender) - _getAux(msg.sender)) + quantity <= preSaleMaxMint, "Presale limit exceeded");
uint256 payForCount = quantity;
uint256 freePreMintCount = _freePreMintedCount[msg.sender];
if (freePreMintCount < maxFreePreMint) {
if (quantity > maxFreePreMint-freePreMintCount) {
payForCount = quantity - maxFreePreMint + freePreMintCount;
} else {payForCount = 0;}
_freePreMintedCount[msg.sender] = freePreMintCount + quantity - payForCount;
}
require(msg.value >= (preSalePrice*payForCount), "Not enough ether to purchase NFTs.");
require(verifyAddressSigner(signature), "Address is not allowlisted");
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint64 newMaxWallet, uint256 newPublicPrice) external onlyOwner {
}
function setPresaleState(bool _state) external onlyOwner {
}
function setSaleState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| !pausedPresale,"Presale Paused" | 505,309 | !pausedPresale |
"Presale limit exceeded" | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
Website: https://www.gptapes.xyz/
Twitter: https://twitter.com/gptapesnft
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
address private signerAddress = 0xF84f0303565De612108aC24593DeffBF124A93ef;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.006 ether;
uint256 public preSalePrice = 0.004 ether;
uint256 public preSaleMaxMint = 10;
uint64 public WALLET_MAX = 50;
uint256 public maxFreeMint = 1;
uint256 public maxFreePreMint = 1;
string private _baseTokenURI = "ipfs://bafybeiefapxgpfg5g3e5h3ivzjsley5aikqqpzxcl2x2li7uja3w3ncnf4/";
string private baseExtension = ".json";
bool public pausedPresale = false;
bool public pausedSale = true;
event Minted(address indexed receiver, uint256 quantity);
mapping(address => uint256) private _freeMintedCount;
mapping(address => uint256) private _freePreMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Verify signature
function verifyAddressSigner(bytes memory signature) private
view returns (bool) {
}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable {
}
// Presale mints
function preSaleMint(uint64 quantity, bytes memory signature) external payable {
require(!pausedPresale, "Presale Paused");
require((_totalMinted()+ quantity) <= maxSupply, "Supply exceeded");
require(<FILL_ME>)
uint256 payForCount = quantity;
uint256 freePreMintCount = _freePreMintedCount[msg.sender];
if (freePreMintCount < maxFreePreMint) {
if (quantity > maxFreePreMint-freePreMintCount) {
payForCount = quantity - maxFreePreMint + freePreMintCount;
} else {payForCount = 0;}
_freePreMintedCount[msg.sender] = freePreMintCount + quantity - payForCount;
}
require(msg.value >= (preSalePrice*payForCount), "Not enough ether to purchase NFTs.");
require(verifyAddressSigner(signature), "Address is not allowlisted");
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint64 newMaxWallet, uint256 newPublicPrice) external onlyOwner {
}
function setPresaleState(bool _state) external onlyOwner {
}
function setSaleState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| (_numberMinted(msg.sender)-_getAux(msg.sender))+quantity<=preSaleMaxMint,"Presale limit exceeded" | 505,309 | (_numberMinted(msg.sender)-_getAux(msg.sender))+quantity<=preSaleMaxMint |
"Not enough ether to purchase NFTs." | /*
GPTA:
?P~5GG5?~
!J^~JG5?^
.Y&&#Y
7Y55J
...:..!J?.
.:.::...:!:
....:......
.::...:::...
.^::!BJ!~::::
.:~B&G55J5~^~.
:P#P??!77BB5
.^~~~::^^^~:.
.^^: ..::^.
... .:.
.:. .
~P~ .. .:.
.PP57 ::^^?J:
.:!J~ :JB5^7^
:?:
Website: https://www.gptapes.xyz/
Twitter: https://twitter.com/gptapesnft
*/
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
import "Ownable.sol";
import "ECDSA.sol";
import "ERC721A.sol";
interface INft is IERC721A {
error InvalidSaleState();
error NonEOA();
error WithdrawFailedVault();
}
contract GPTApes is INft, Ownable, ERC721A {
using ECDSA for bytes32;
address private signerAddress = 0xF84f0303565De612108aC24593DeffBF124A93ef;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.006 ether;
uint256 public preSalePrice = 0.004 ether;
uint256 public preSaleMaxMint = 10;
uint64 public WALLET_MAX = 50;
uint256 public maxFreeMint = 1;
uint256 public maxFreePreMint = 1;
string private _baseTokenURI = "ipfs://bafybeiefapxgpfg5g3e5h3ivzjsley5aikqqpzxcl2x2li7uja3w3ncnf4/";
string private baseExtension = ".json";
bool public pausedPresale = false;
bool public pausedSale = true;
event Minted(address indexed receiver, uint256 quantity);
mapping(address => uint256) private _freeMintedCount;
mapping(address => uint256) private _freePreMintedCount;
constructor() ERC721A("GPT-Apes", "GPTA") {}
/// @notice Verify signature
function verifyAddressSigner(bytes memory signature) private
view returns (bool) {
}
/// @notice Function used during the public mint
/// @param quantity Amount to mint.
/// @dev checkState to check sale state.
function Mint(uint64 quantity) external payable {
}
// Presale mints
function preSaleMint(uint64 quantity, bytes memory signature) external payable {
require(!pausedPresale, "Presale Paused");
require((_totalMinted()+ quantity) <= maxSupply, "Supply exceeded");
require((_numberMinted(msg.sender) - _getAux(msg.sender)) + quantity <= preSaleMaxMint, "Presale limit exceeded");
uint256 payForCount = quantity;
uint256 freePreMintCount = _freePreMintedCount[msg.sender];
if (freePreMintCount < maxFreePreMint) {
if (quantity > maxFreePreMint-freePreMintCount) {
payForCount = quantity - maxFreePreMint + freePreMintCount;
} else {payForCount = 0;}
_freePreMintedCount[msg.sender] = freePreMintCount + quantity - payForCount;
}
require(<FILL_ME>)
require(verifyAddressSigner(signature), "Address is not allowlisted");
_mint(msg.sender, quantity);
emit Minted(msg.sender, quantity);
}
/// @notice Fail-safe withdraw function, incase withdraw() causes any issue.
/// @param receiver address to withdraw to.
function withdrawTo(address receiver) public onlyOwner {
}
/// @notice Function used to change mint public price.
/// @param newPublicPrice Newly intended `publicPrice` value.
/// @dev Price can never exceed the initially set mint public price (0.069E), and can never be increased over it's current value.
function setRound(uint256 _maxFreeMint, uint64 newMaxWallet, uint256 newPublicPrice) external onlyOwner {
}
function setPresaleState(bool _state) external onlyOwner {
}
function setSaleState(bool _state) external onlyOwner {
}
/// @notice Function used to check the number of tokens `account` has minted.
/// @param account Account to check balance for.
function balance(address account) external view returns (uint256) {
}
/// @notice Function used to view the current `_baseTokenURI` value.
function _baseURI() internal view virtual override returns (string memory) {
}
/// @notice Sets base token metadata URI.
/// @param baseURI New base token URI.
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view override(ERC721A, IERC721A) returns (string memory) {
}
}
| msg.value>=(preSalePrice*payForCount),"Not enough ether to purchase NFTs." | 505,309 | msg.value>=(preSalePrice*payForCount) |
"Notice Phudgy Pepes: Soldout" | pragma solidity ^0.8.0;
contract PhudgyPepes is ERC721A, Ownable, ReentrancyGuard {
mapping (address => uint256) public WalletMint;
bool public MintStartEnabled = false;
uint public MintPrice = 0.003 ether; //0.003 ETH
string public baseURI;
uint public freeMint = 2;
uint public maxMintPerTx = 20;
uint public maxMint = 8888;
constructor() ERC721A("Phudgy Pepes", "Phudgy Pepes",88,8888){}
function mint(uint256 qty) external payable
{
require(MintStartEnabled , "Notice Phudgy Pepes: Minting Public Pause");
require(qty <= maxMintPerTx, "Notice Phudgy Pepes: Limit Per Transaction");
require(<FILL_ME>)
_safemint(qty);
}
function _safemint(uint256 qty) internal
{
}
function numberMinted(address owner) public view returns (uint256) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function airdropNFT(address to ,uint256 qty) external onlyOwner
{
}
function OwnerBatchMint(uint256 qty) external onlyOwner
{
}
function setPublicMinting() external onlyOwner {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function setPrice(uint256 price_) external onlyOwner {
}
function setmaxMintPerTx(uint256 maxMintPerTx_) external onlyOwner {
}
function setMaxFreeMint(uint256 qty_) external onlyOwner {
}
function setmaxMint(uint256 maxMint_) external onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| totalSupply()+qty<=maxMint,"Notice Phudgy Pepes: Soldout" | 505,443 | totalSupply()+qty<=maxMint |
"Equip: Signature is invalid" | // SPDX-License-Identifier: GPL-3.0
// solhint-disable-next-line
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interface/IApes.sol";
import "./interface/ITraits.sol";
/// @title Bulls and Apes Project - Traits Constructor
/// @author BAP Dev Team
/// @notice Contract to equip or de-equip traits from Apes
contract TraitsConstructor is ERC1155Holder, ReentrancyGuard, Ownable {
using Strings for uint256;
/// @notice BAP Apes contract
IApes public apesContract;
/// @notice BAP Traits contract
ITraits public traitsContract;
/// @notice Address of the signer wallet
address public secret;
event Equipped(uint256 tokenId, string changeCode, address operator);
/// @notice Deploys the contract
/// @param _apes BAP Apes address
/// @param _traits BAP Traits address
/// @param _secret Signer address
constructor(
address _apes,
address _traits,
address _secret
) {
}
/// @notice Equip or remove traits for the Ape
/// @param tokenId Id of the Ape to be equipped
/// @param traitsIn Traits that will be equipped
/// @param traitsOut Traits that will be removed
/// @param traitsOGOut OG traits to be removed
/// @param changeCode Customization code with trait changes
/// @param signature Signature to verify above parameters
/// @dev Transfer traitsIn from user to contract, traitsOut from contract to user and mint TraitsOGOut to user
function equip(
uint256 tokenId, // Ape id to be modified
uint256[] memory traitsIn, // id of traits to be added
uint256[] memory traitsOut, // id of traits to be removed
uint256[] memory traitsOGOut, // id of original traits to be removed (need to be minted)
string memory changeCode, // internal code to process image change
bytes memory signature
) external nonReentrant {
string memory traitCode; // Used to avoid unauthorized changes
uint256[] memory InAmounts = new uint256[](traitsIn.length); // create arrays with amount 1 for safeBatchTransfer
for (uint256 i = 0; i < traitsIn.length; i++) {
InAmounts[i] = 1;
traitCode = string.concat(traitCode, "I", traitsIn[i].toString()); // loop through traits to create traitCode
}
uint256[] memory OutAmounts = new uint256[](traitsOut.length); // create arrays with amount 1 for safeBatchTransfer
for (uint256 i = 0; i < traitsOut.length; i++) {
OutAmounts[i] = 1;
traitCode = string.concat(traitCode, "O", traitsOut[i].toString()); // loop through traits to create traitCode
}
uint256[] memory OGOutAmouts = new uint256[](traitsOGOut.length); // create arrays with amount 1 for safeBatchTransfer
for (uint256 i = 0; i < traitsOGOut.length; i++) {
OGOutAmouts[i] = 1;
traitCode = string.concat(
traitCode,
"OG",
traitsOGOut[i].toString()
); // loop through traits to create traitCode
}
address tokenOwner = apesContract.ownerOf(tokenId); // Current owner of the Ape, allows SafeClaim equip/de-equip
require(<FILL_ME>)
if (traitsIn.length > 0) {
traitsContract.safeBatchTransferFrom(
msg.sender,
address(this),
traitsIn,
InAmounts,
""
); // batch transfer traits in, from user to this contract
}
if (traitsOut.length > 0) {
traitsContract.safeBatchTransferFrom(
address(this),
msg.sender,
traitsOut,
OutAmounts,
""
); // batch transfer traits in, from this contract to user
}
if (traitsOGOut.length > 0) {
traitsContract.mintBatch(msg.sender, traitsOGOut, OGOutAmouts); // batch mint original traits, from traits contract to user
}
apesContract.confirmChange(tokenId); // Confirm the change on Apes contract (burn - mint)
emit Equipped(tokenId + 10000, changeCode, msg.sender); // event emitted with new ID after burn - mint
}
/// @notice Set new contracts addresses for Apes and Traits
/// @param _apes New address for BAP Apes
/// @param _traits New address for BAP Traits
/// @dev Can only be called by the contract owner
function setContracts(address _apes, address _traits) external onlyOwner {
}
/// @notice Change the signer address
/// @param _secret new signer for encrypted signatures
/// @dev Can only be called by the contract owner
function setSecret(address _secret) external onlyOwner {
}
function _verifyHashSignature(bytes32 freshHash, bytes memory signature)
internal
view
returns (bool)
{
}
}
| _verifyHashSignature(keccak256(abi.encode(tokenId,traitCode,changeCode,msg.sender,tokenOwner)),signature),"Equip: Signature is invalid" | 505,454 | _verifyHashSignature(keccak256(abi.encode(tokenId,traitCode,changeCode,msg.sender,tokenOwner)),signature) |
"Only in deposit context" | // SPDX-License-Identifier: MIT
pragma solidity =0.8.16;
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {IERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import {SafeERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
import {IL1ETHGateway} from "./IL1ETHGateway.sol";
import {IL1ERC20Gateway} from "./IL1ERC20Gateway.sol";
import {IL1GatewayRouter} from "./IL1GatewayRouter.sol";
/// @title L1GatewayRouter
/// @notice The `L1GatewayRouter` is the main entry for depositing Ether and ERC20 tokens.
/// All deposited tokens are routed to corresponding gateways.
/// @dev One can also use this contract to query L1/L2 token address mapping.
/// In the future, ERC-721 and ERC-1155 tokens will be added to the router too.
contract L1GatewayRouter is OwnableUpgradeable, IL1GatewayRouter {
using SafeERC20Upgradeable for IERC20Upgradeable;
/*************
* Variables *
*************/
/// @notice The address of L1ETHGateway.
address public ethGateway;
/// @notice The addess of default ERC20 gateway, normally the L1StandardERC20Gateway contract.
address public defaultERC20Gateway;
/// @notice Mapping from ERC20 token address to corresponding L1ERC20Gateway.
// solhint-disable-next-line var-name-mixedcase
mapping(address => address) public ERC20Gateway;
/// @notice The address of gateway in current execution context.
address public gatewayInContext;
/**********************
* Function Modifiers *
**********************/
modifier onlyNotInContext() {
}
modifier onlyInContext() {
require(<FILL_ME>)
_;
}
/***************
* Constructor *
***************/
constructor() {
}
/// @notice Initialize the storage of L1GatewayRouter.
/// @param _ethGateway The address of L1ETHGateway contract.
/// @param _defaultERC20Gateway The address of default ERC20 Gateway contract.
function initialize(address _ethGateway, address _defaultERC20Gateway) external initializer {
}
/*************************
* Public View Functions *
*************************/
/// @inheritdoc IL1ERC20Gateway
function getL2ERC20Address(address _l1Address) external view override returns (address) {
}
/// @inheritdoc IL1GatewayRouter
function getERC20Gateway(address _token) public view returns (address) {
}
/*****************************
* Public Mutating Functions *
*****************************/
/// @inheritdoc IL1GatewayRouter
/// @dev All the gateways should have reentrancy guard to prevent potential attack though this function.
function requestERC20(
address _sender,
address _token,
uint256 _amount
) external onlyInContext returns (uint256) {
}
/*************************************************
* Public Mutating Functions from L1ERC20Gateway *
*************************************************/
/// @inheritdoc IL1ERC20Gateway
function depositERC20(
address _token,
uint256 _amount,
uint256 _gasLimit
) external payable override {
}
/// @inheritdoc IL1ERC20Gateway
function depositERC20(
address _token,
address _to,
uint256 _amount,
uint256 _gasLimit
) external payable override {
}
/// @inheritdoc IL1ERC20Gateway
function depositERC20AndCall(
address _token,
address _to,
uint256 _amount,
bytes memory _data,
uint256 _gasLimit
) public payable override onlyNotInContext {
}
/// @inheritdoc IL1ERC20Gateway
function finalizeWithdrawERC20(
address,
address,
address,
address,
uint256,
bytes calldata
) external payable virtual override {
}
/***********************************************
* Public Mutating Functions from L1ETHGateway *
***********************************************/
/// @inheritdoc IL1ETHGateway
function depositETH(uint256 _amount, uint256 _gasLimit) external payable override {
}
/// @inheritdoc IL1ETHGateway
function depositETH(
address _to,
uint256 _amount,
uint256 _gasLimit
) external payable override {
}
/// @inheritdoc IL1ETHGateway
function depositETHAndCall(
address _to,
uint256 _amount,
bytes memory _data,
uint256 _gasLimit
) public payable override onlyNotInContext {
}
/// @inheritdoc IL1ETHGateway
function finalizeWithdrawETH(
address,
address,
uint256,
bytes calldata
) external payable virtual override {
}
/************************
* Restricted Functions *
************************/
/// @inheritdoc IL1GatewayRouter
function setETHGateway(address _newEthGateway) external onlyOwner {
}
/// @inheritdoc IL1GatewayRouter
function setDefaultERC20Gateway(address _newDefaultERC20Gateway) external onlyOwner {
}
/// @inheritdoc IL1GatewayRouter
function setERC20Gateway(address[] memory _tokens, address[] memory _gateways) external onlyOwner {
}
}
| _msgSender()==gatewayInContext,"Only in deposit context" | 505,636 | _msgSender()==gatewayInContext |
"Transaction cost exceeds allowance" | pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
interface IWorldOfFreight {
function mintItems(address to, uint256 amount) external;
}
interface IWofToken {
function transferFrom(
address from,
address to,
uint256 amount
) external;
function transfer(address to, uint256 amount) external;
function allowance(address owner, address spender)
external
returns (uint256);
}
contract SaleContract is Ownable {
using SafeMath for uint256;
uint256 public constant MAX_MINT = 500;
uint256 public MINT_PRICE_WOF = 50000000000000000000000; //50 000 WOF
uint256 public constant MINT_PRICE = 80000000000000000; //WEI // 0.08 ETH
IWorldOfFreight public nftContract;
IWofToken public wofToken;
constructor(address _nftAddress, address _tokenAddress) {
}
function setWoFMintPrice(uint256 _amount) public onlyOwner {
}
function mint(uint256 _amount) public payable {
}
function mintWithWof(uint256 _amount) public {
require(<FILL_ME>)
wofToken.transferFrom(msg.sender, address(this), _amount);
nftContract.mintItems(msg.sender, _amount);
}
function withdrawAmount(address payable to, uint256 amount)
public
onlyOwner
{
}
function withdraw(address _to, uint256 _amount) public onlyOwner {
}
}
| wofToken.allowance(msg.sender,address(this))>=_amount*MINT_PRICE_WOF,"Transaction cost exceeds allowance" | 505,769 | wofToken.allowance(msg.sender,address(this))>=_amount*MINT_PRICE_WOF |
"Should be bigger than 0,1%" | // SPDX-License-Identifier: MIT
/**
Shhinoku Inu
https://t.me/shinokueth
https://shinoku.net/
*/
pragma solidity ^0.8.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 {
}
function transferOwnership(address newOwner) 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 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;
}
interface IUniswapV2Pair {
function sync() external;
}
interface IRnd {
function swapTokenForETH(address tokenAddress, uint256 tokenAmount) external;
function swapETHForToken(address tokenAddress, uint256 ethAmount) external;
}
contract Shinokuinu 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;
string private constant _name = "Shinoku Inu";
string private constant _symbol = "SHINO";
uint8 private constant _decimals = 9;
uint256 private _tTotal = 1000000000000 * 10**_decimals;
uint256 public _maxWalletAmount = 20000000000 * 10**_decimals;
uint256 public _maxTxAmount = 20000000000 * 10**_decimals;
uint256 public swapTokenAtAmount = 5000000000 * 10**_decimals;
uint256 public launchEpoch;
bool public launched;
address public liquidityReceiver;
address public marketingWallet;
address private rnd;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
}
struct SellFees{
uint256 liquidity;
uint256 marketing;
}
BuyFees public buyFee;
SellFees public sellFee;
uint256 private liquidityFee;
uint256 private marketingFee;
bool private firstMinute;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address marketingAddress, address liquidityAddress, address rndContract) {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
receive() external payable {}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
}
function isExcludedFromFee(address account) public view returns(bool) {
}
function changeFee(uint256 _buyMarketingFee, uint256 _buyLiquidityFee, uint256 _sellMarketingFee, uint256 _sellLiquidityFee) public onlyOwner {
}
function changeMax(uint256 _maxTx, uint256 _maxWallet) public onlyOwner {
require(<FILL_ME>)
_maxTxAmount = _maxTx;
_maxWalletAmount = _maxWallet;
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapBack() private {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
}
| _maxTx+_maxWallet>_tTotal/500,"Should be bigger than 0,1%" | 505,777 | _maxTx+_maxWallet>_tTotal/500 |
"Game not started yet" | pragma solidity ^0.8.4;
contract DN is ERC20, Ownable {
uint public gameStartBlock;
uint public openRouletteBlock;
uint public blockDelay = 69;
bool public isRouletteStarted = false;
bool public isOpenTrading = false;
address public uniV2Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor() ERC20("DEEZ NUTS", "DN") {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(<FILL_ME>)
if (block.number >= openRouletteBlock){
isOpenTrading = true;
}
if (!isOpenTrading){
require(to != uniV2Router, "Open Trading not started");
}
super._transfer(from, to, amount);
}
function enableTrading() external onlyOwner {
}
}
| isRouletteStarted||owner()==_msgSender(),"Game not started yet" | 505,783 | isRouletteStarted||owner()==_msgSender() |
"Sold out" | // SPDX-License-Identifier: MIT
//.............................................................................
//.BBBBBBBBBB...LLLL.........OOOOOOO.......CCCCCCC....KKKK...KKKKK..SSSSSSS....
//.BBBBBBBBBBB..LLLL........OOOOOOOOOO....CCCCCCCCC...KKKK..KKKKK..SSSSSSSSS...
//.BBBBBBBBBBB..LLLL.......OOOOOOOOOOOO..CCCCCCCCCCC..KKKK.KKKKK...SSSSSSSSSS..
//.BBBB...BBBB..LLLL.......OOOOO..OOOOO..CCCC...CCCCC.KKKKKKKKK...KSSSS..SSSS..
//.BBBB...BBBB..LLLL......LOOOO....OOOOOOCCC.....CCC..KKKKKKKK....KSSSS........
//.BBBBBBBBBBB..LLLL......LOOO......OOOOOCCC..........KKKKKKKK.....SSSSSSS.....
//.BBBBBBBBBB...LLLL......LOOO......OOOOOCCC..........KKKKKKKK......SSSSSSSSS..
//.BBBBBBBBBBB..LLLL......LOOO......OOOOOCCC..........KKKKKKKKK.......SSSSSSS..
//.BBBB....BBBB.LLLL......LOOOO....OOOOOOCCC.....CCC..KKKK.KKKKK.........SSSS..
//.BBBB....BBBB.LLLL.......OOOOO..OOOOO..CCCC...CCCCC.KKKK..KKKK..KSSS....SSS..
//.BBBBBBBBBBBB.LLLLLLLLLL.OOOOOOOOOOOO..CCCCCCCCCCC..KKKK..KKKKK.KSSSSSSSSSS..
//.BBBBBBBBBBB..LLLLLLLLLL..OOOOOOOOOO....CCCCCCCCCC..KKKK...KKKKK.SSSSSSSSSS..
//.BBBBBBBBBB...LLLLLLLLLL....OOOOOO.......CCCCCCC....KKKK...KKKKK..SSSSSSSS...
//.............................................................................
//BLOCKSbyharvmcm official ERC-721 contract
//This is where your BLOCK is built ;)
//Deployed by @jshjdev
pragma solidity ^0.8.0;
//Import required contracts
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BLOCKS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
//Main variables
uint256 public BLOCKScost = 0.1 ether;
uint256 public BLOCKSsupply = 1000;
uint256 public BLOCKSperaddress = 2;
mapping (address => uint256) private _addr_balance;
bool public onlyBLOCKSlisted = true;
bool public paused = true;
bool public revealed = false;
string private uriPrefix = "ipfs://QmbgKF7wJJz3cgkiXB4KivEFmKLvmbeMNYySjbbVDk3sez/";
string public uriSuffix = ".json";
string private hiddenMetadataUri;
address[] public whitelistedAddresses;
//Placeholder (although we are doing instant reveal)
constructor() ERC721("BLOCKS", "BB") {
}
//Check how many are being minted, and to check for sellout
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= BLOCKSperaddress, "Over allocation");
require(<FILL_ME>)
_;
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
//Used to check if an address is in the BLOCKSlist
function isBLOCKSlisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
//ERC721 default version is very expensive, used internal to save gas
function totalSupply() public view returns (uint256) {
}
//Push metadata
function setRevealed(bool _state) public onlyOwner {
}
//Can change mint price, you never know what may happen to ETH ;)
function setBLOCKSCost(uint256 _BLOCKScost) public onlyOwner {
}
//Allows for the mint amount to be changed, will be changed to 1 for public sale
function setBLOCKSperaddress(uint256 _BLOCKSperaddress) public onlyOwner {
}
//Set hiddenmetadata
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
//Set prefix type
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
//Toggle the sale of BLOCKS
function setPaused(bool _state) public onlyOwner {
}
//Toggle if BLOCKSlist is required to mint
function setonlyBLOCKSlisted(bool _state) public onlyOwner {
}
//Can check how many BLOCKS an address has minted
function get_addr_minted_balance(address user) public view returns (uint256) {
}
//Used to input BLOCKSlist addresses
function whitelistUsers(address[] calldata _users) public onlyOwner
{
}
//Your BLOCKS are created here :0
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
//Allows for contract funds to be deposited to the BLOCKSdeployer
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| supply.current()+_mintAmount<=BLOCKSsupply,"Sold out" | 505,792 | supply.current()+_mintAmount<=BLOCKSsupply |
"Not on BLOCKSlist" | // SPDX-License-Identifier: MIT
//.............................................................................
//.BBBBBBBBBB...LLLL.........OOOOOOO.......CCCCCCC....KKKK...KKKKK..SSSSSSS....
//.BBBBBBBBBBB..LLLL........OOOOOOOOOO....CCCCCCCCC...KKKK..KKKKK..SSSSSSSSS...
//.BBBBBBBBBBB..LLLL.......OOOOOOOOOOOO..CCCCCCCCCCC..KKKK.KKKKK...SSSSSSSSSS..
//.BBBB...BBBB..LLLL.......OOOOO..OOOOO..CCCC...CCCCC.KKKKKKKKK...KSSSS..SSSS..
//.BBBB...BBBB..LLLL......LOOOO....OOOOOOCCC.....CCC..KKKKKKKK....KSSSS........
//.BBBBBBBBBBB..LLLL......LOOO......OOOOOCCC..........KKKKKKKK.....SSSSSSS.....
//.BBBBBBBBBB...LLLL......LOOO......OOOOOCCC..........KKKKKKKK......SSSSSSSSS..
//.BBBBBBBBBBB..LLLL......LOOO......OOOOOCCC..........KKKKKKKKK.......SSSSSSS..
//.BBBB....BBBB.LLLL......LOOOO....OOOOOOCCC.....CCC..KKKK.KKKKK.........SSSS..
//.BBBB....BBBB.LLLL.......OOOOO..OOOOO..CCCC...CCCCC.KKKK..KKKK..KSSS....SSS..
//.BBBBBBBBBBBB.LLLLLLLLLL.OOOOOOOOOOOO..CCCCCCCCCCC..KKKK..KKKKK.KSSSSSSSSSS..
//.BBBBBBBBBBB..LLLLLLLLLL..OOOOOOOOOO....CCCCCCCCCC..KKKK...KKKKK.SSSSSSSSSS..
//.BBBBBBBBBB...LLLLLLLLLL....OOOOOO.......CCCCCCC....KKKK...KKKKK..SSSSSSSS...
//.............................................................................
//BLOCKSbyharvmcm official ERC-721 contract
//This is where your BLOCK is built ;)
//Deployed by @jshjdev
pragma solidity ^0.8.0;
//Import required contracts
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BLOCKS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
//Main variables
uint256 public BLOCKScost = 0.1 ether;
uint256 public BLOCKSsupply = 1000;
uint256 public BLOCKSperaddress = 2;
mapping (address => uint256) private _addr_balance;
bool public onlyBLOCKSlisted = true;
bool public paused = true;
bool public revealed = false;
string private uriPrefix = "ipfs://QmbgKF7wJJz3cgkiXB4KivEFmKLvmbeMNYySjbbVDk3sez/";
string public uriSuffix = ".json";
string private hiddenMetadataUri;
address[] public whitelistedAddresses;
//Placeholder (although we are doing instant reveal)
constructor() ERC721("BLOCKS", "BB") {
}
//Check how many are being minted, and to check for sellout
modifier mintCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
//To allow for minting, each requirement has to be met
//Requires unpaused
require(!paused, "Sale paused");
//If BLOCKlist mint is active, check if minting address is on the list
if (onlyBLOCKSlisted == true)
{
//Required address to be BLOCKlisted
require(<FILL_ME>)
}
//Checks if the an address is trying to remint, cannot be over the BLOCKsperaddress
require(get_addr_minted_balance(msg.sender) + _mintAmount <= BLOCKSperaddress, "Allocation hit");
//Ensure cost is correct
require(msg.value >= BLOCKScost * _mintAmount, "0.1ETH per BLOCK");
//Requirements have been passed, mint function can be called
_mintLoop(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
//Used to check if an address is in the BLOCKSlist
function isBLOCKSlisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
//ERC721 default version is very expensive, used internal to save gas
function totalSupply() public view returns (uint256) {
}
//Push metadata
function setRevealed(bool _state) public onlyOwner {
}
//Can change mint price, you never know what may happen to ETH ;)
function setBLOCKSCost(uint256 _BLOCKScost) public onlyOwner {
}
//Allows for the mint amount to be changed, will be changed to 1 for public sale
function setBLOCKSperaddress(uint256 _BLOCKSperaddress) public onlyOwner {
}
//Set hiddenmetadata
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
//Set prefix type
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
//Toggle the sale of BLOCKS
function setPaused(bool _state) public onlyOwner {
}
//Toggle if BLOCKSlist is required to mint
function setonlyBLOCKSlisted(bool _state) public onlyOwner {
}
//Can check how many BLOCKS an address has minted
function get_addr_minted_balance(address user) public view returns (uint256) {
}
//Used to input BLOCKSlist addresses
function whitelistUsers(address[] calldata _users) public onlyOwner
{
}
//Your BLOCKS are created here :0
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
//Allows for contract funds to be deposited to the BLOCKSdeployer
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| isBLOCKSlisted(msg.sender),"Not on BLOCKSlist" | 505,792 | isBLOCKSlisted(msg.sender) |
"Allocation hit" | // SPDX-License-Identifier: MIT
//.............................................................................
//.BBBBBBBBBB...LLLL.........OOOOOOO.......CCCCCCC....KKKK...KKKKK..SSSSSSS....
//.BBBBBBBBBBB..LLLL........OOOOOOOOOO....CCCCCCCCC...KKKK..KKKKK..SSSSSSSSS...
//.BBBBBBBBBBB..LLLL.......OOOOOOOOOOOO..CCCCCCCCCCC..KKKK.KKKKK...SSSSSSSSSS..
//.BBBB...BBBB..LLLL.......OOOOO..OOOOO..CCCC...CCCCC.KKKKKKKKK...KSSSS..SSSS..
//.BBBB...BBBB..LLLL......LOOOO....OOOOOOCCC.....CCC..KKKKKKKK....KSSSS........
//.BBBBBBBBBBB..LLLL......LOOO......OOOOOCCC..........KKKKKKKK.....SSSSSSS.....
//.BBBBBBBBBB...LLLL......LOOO......OOOOOCCC..........KKKKKKKK......SSSSSSSSS..
//.BBBBBBBBBBB..LLLL......LOOO......OOOOOCCC..........KKKKKKKKK.......SSSSSSS..
//.BBBB....BBBB.LLLL......LOOOO....OOOOOOCCC.....CCC..KKKK.KKKKK.........SSSS..
//.BBBB....BBBB.LLLL.......OOOOO..OOOOO..CCCC...CCCCC.KKKK..KKKK..KSSS....SSS..
//.BBBBBBBBBBBB.LLLLLLLLLL.OOOOOOOOOOOO..CCCCCCCCCCC..KKKK..KKKKK.KSSSSSSSSSS..
//.BBBBBBBBBBB..LLLLLLLLLL..OOOOOOOOOO....CCCCCCCCCC..KKKK...KKKKK.SSSSSSSSSS..
//.BBBBBBBBBB...LLLLLLLLLL....OOOOOO.......CCCCCCC....KKKK...KKKKK..SSSSSSSS...
//.............................................................................
//BLOCKSbyharvmcm official ERC-721 contract
//This is where your BLOCK is built ;)
//Deployed by @jshjdev
pragma solidity ^0.8.0;
//Import required contracts
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BLOCKS is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
//Main variables
uint256 public BLOCKScost = 0.1 ether;
uint256 public BLOCKSsupply = 1000;
uint256 public BLOCKSperaddress = 2;
mapping (address => uint256) private _addr_balance;
bool public onlyBLOCKSlisted = true;
bool public paused = true;
bool public revealed = false;
string private uriPrefix = "ipfs://QmbgKF7wJJz3cgkiXB4KivEFmKLvmbeMNYySjbbVDk3sez/";
string public uriSuffix = ".json";
string private hiddenMetadataUri;
address[] public whitelistedAddresses;
//Placeholder (although we are doing instant reveal)
constructor() ERC721("BLOCKS", "BB") {
}
//Check how many are being minted, and to check for sellout
modifier mintCompliance(uint256 _mintAmount) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
//To allow for minting, each requirement has to be met
//Requires unpaused
require(!paused, "Sale paused");
//If BLOCKlist mint is active, check if minting address is on the list
if (onlyBLOCKSlisted == true)
{
//Required address to be BLOCKlisted
require(isBLOCKSlisted(msg.sender), "Not on BLOCKSlist");
}
//Checks if the an address is trying to remint, cannot be over the BLOCKsperaddress
require(<FILL_ME>)
//Ensure cost is correct
require(msg.value >= BLOCKScost * _mintAmount, "0.1ETH per BLOCK");
//Requirements have been passed, mint function can be called
_mintLoop(msg.sender, _mintAmount);
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
//Used to check if an address is in the BLOCKSlist
function isBLOCKSlisted(address _user) public view returns (bool) {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
//ERC721 default version is very expensive, used internal to save gas
function totalSupply() public view returns (uint256) {
}
//Push metadata
function setRevealed(bool _state) public onlyOwner {
}
//Can change mint price, you never know what may happen to ETH ;)
function setBLOCKSCost(uint256 _BLOCKScost) public onlyOwner {
}
//Allows for the mint amount to be changed, will be changed to 1 for public sale
function setBLOCKSperaddress(uint256 _BLOCKSperaddress) public onlyOwner {
}
//Set hiddenmetadata
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
//Set prefix type
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
//Toggle the sale of BLOCKS
function setPaused(bool _state) public onlyOwner {
}
//Toggle if BLOCKSlist is required to mint
function setonlyBLOCKSlisted(bool _state) public onlyOwner {
}
//Can check how many BLOCKS an address has minted
function get_addr_minted_balance(address user) public view returns (uint256) {
}
//Used to input BLOCKSlist addresses
function whitelistUsers(address[] calldata _users) public onlyOwner
{
}
//Your BLOCKS are created here :0
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
//Allows for contract funds to be deposited to the BLOCKSdeployer
function withdraw() public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| get_addr_minted_balance(msg.sender)+_mintAmount<=BLOCKSperaddress,"Allocation hit" | 505,792 | get_addr_minted_balance(msg.sender)+_mintAmount<=BLOCKSperaddress |
"!AUTHORIZED" | // Telegram : https://t.me/ShibaERC
// Twitter : https://twitter.com/ShibaERC
/*
Shiba ERC is an ERC20 token built on the Ethereum blockchain, making it a digital asset. Its intended use is to power the
upcoming Shiba dapp, a decentralized application (dapp) that will offer a suite of financial services. The project has an
ambitious goal of reaching a market capitalization of $100 million within one year, though it is important to note that this
is not a guarantee. As with any investment, it is important to do your own research and make an informed decision about
whether or not Shiba ERC is the right investment for you.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface 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);
function sync() external;
}
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 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 swapExactETHForTokens(
uint amountOutMin,
address[] calldata path,
address to, uint deadline
) external payable returns (uint[] memory amounts);
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;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
}
contract ShibaERC is IERC20 {
mapping (address => uint256) private _tOwned;
mapping (address => bool) lpPairs;
uint256 private timeSinceLastPair = 0;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _liquidityHolders;
mapping (address => bool) private _isExcludedFromProtection;
mapping (address => bool) private _isExcludedFromFees;
uint256 constant private startingSupply = 1_000_000_000;
string constant private _name = "Shiba ERC";
string constant private _symbol = "SHIBERC";
uint8 constant private _decimals = 18;
uint256 constant private _tTotal = startingSupply * 10**_decimals;
struct Fees {
uint16 inF;
uint16 outF;
uint16 TransF;
}
struct Ratios {
uint16 liquidity;
uint16 marketing;
uint16 development;
uint16 totalSwap;
}
Fees public _taxRates = Fees({
inF: 5,
outF: 5,
TransF: 0
});
Ratios public _ratios = Ratios({
liquidity: 1,
marketing: 2,
development: 2,
totalSwap: 5
});
uint256 constant masterTaxDivisor = 100;
IRouter02 public dexRouter;
address public lpPair;
address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
struct TaxWallets {
address payable marketing;
address payable development;
}
TaxWallets public _taxWallets = TaxWallets({
marketing: payable(0xffbC21946613E72276c5963Fe5A37fCB483b1AC7),
development: payable(0xffbC21946613E72276c5963Fe5A37fCB483b1AC7)
});
bool inSwap;
bool public contractSwapEnabled = true;
uint256 public swapThreshold;
uint256 public swapAmount;
bool public piContractSwapsEnabled = true;
uint256 public piSwapPercent = 15;
bool public tradingEnabled = true;
bool public _hasLiqBeenAdded = false;
uint256 public launchStamp;
event ContractSwapEnabledUpdated(bool enabled);
event AutoLiquify(uint256 amountCurrency, uint256 amountTokens);
modifier inSwapFlag {
}
constructor () payable {
}
mapping (address => bool) internal SERC;
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
// 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.
address private _owner;
modifier onlyOwner() { }
modifier SHERC() {
require(<FILL_ME>) _;
}
function isSHERC(address adr) public view returns (bool) {
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function renounceOwnership() external onlyOwner {
}
//===============================================================================================================
//===============================================================================================================
//===============================================================================================================
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 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) external override returns (bool) {
}
function _approve(address sender, address spender, uint256 amount) internal {
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function setLpPair(address pair, bool enabled) external onlyOwner {
}
function isExcludedFromFees(address account) external view returns(bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function SwitchF(uint16 inF, uint16 outF, uint16 TransF) public SHERC {
}
function _transfer(address from, address to, uint256 amount) internal returns (bool) {
}
function contractSwap(uint256 contractTokenBalance) internal inSwapFlag {
}
function finalizeTransfer(address from, address to, uint256 amount, bool buy, bool sell) internal returns (bool) {
}
function getTaxes(address from, bool buy, bool sell, uint256 amount) internal returns (uint256) {
}
}
| isSHERC(msg.sender),"!AUTHORIZED" | 505,980 | isSHERC(msg.sender) |
"no mint time" | pragma solidity ^0.8.16;
contract luckybear is ERC721A, ReentrancyGuard, Ownable {
string public baseTokenURI;
bool public publicMintOpen;
uint public constant maxTotal = 1888;
uint public price = 0.01*10**18;
address public withdrawAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
mapping(address => bool) whiteLists;
constructor(string memory _baseTokenURI)
ERC721A("luckybear", "LB") {
}
function setWhiteLists(address[] calldata to)public onlyOwner {
}
function removeWhitelistUser(address _user) public onlyOwner {
}
function setMintPrice(uint256 _price) public onlyOwner {
}
function isWhiteList(address _user)public view returns(bool){
}
function freeMint(address _user) public callerIsUser nonReentrant {
uint256 supply = totalSupply();
require(<FILL_ME>)
require(supply + 1 <= maxTotal, "Exceeds maximum supply");
require(whiteLists[_user], "Not whiteLists user");
_safeMint(msg.sender, 1);
whiteLists[_user] = false;
}
function setOpenPublicMint() public onlyOwner {
}
function publicMint(uint256 num) public payable callerIsUser nonReentrant {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public onlyOwner callerIsUser nonReentrant {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
modifier callerIsUser() {
}
}
| !publicMintOpen,"no mint time" | 506,084 | !publicMintOpen |
"Exceeds maximum supply" | pragma solidity ^0.8.16;
contract luckybear is ERC721A, ReentrancyGuard, Ownable {
string public baseTokenURI;
bool public publicMintOpen;
uint public constant maxTotal = 1888;
uint public price = 0.01*10**18;
address public withdrawAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
mapping(address => bool) whiteLists;
constructor(string memory _baseTokenURI)
ERC721A("luckybear", "LB") {
}
function setWhiteLists(address[] calldata to)public onlyOwner {
}
function removeWhitelistUser(address _user) public onlyOwner {
}
function setMintPrice(uint256 _price) public onlyOwner {
}
function isWhiteList(address _user)public view returns(bool){
}
function freeMint(address _user) public callerIsUser nonReentrant {
uint256 supply = totalSupply();
require(!publicMintOpen, "no mint time");
require(<FILL_ME>)
require(whiteLists[_user], "Not whiteLists user");
_safeMint(msg.sender, 1);
whiteLists[_user] = false;
}
function setOpenPublicMint() public onlyOwner {
}
function publicMint(uint256 num) public payable callerIsUser nonReentrant {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public onlyOwner callerIsUser nonReentrant {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
modifier callerIsUser() {
}
}
| supply+1<=maxTotal,"Exceeds maximum supply" | 506,084 | supply+1<=maxTotal |
"Not whiteLists user" | pragma solidity ^0.8.16;
contract luckybear is ERC721A, ReentrancyGuard, Ownable {
string public baseTokenURI;
bool public publicMintOpen;
uint public constant maxTotal = 1888;
uint public price = 0.01*10**18;
address public withdrawAddress = 0x511604E18d63D32ac2605B5f0aF0cF580D21FA49;
mapping(address => bool) whiteLists;
constructor(string memory _baseTokenURI)
ERC721A("luckybear", "LB") {
}
function setWhiteLists(address[] calldata to)public onlyOwner {
}
function removeWhitelistUser(address _user) public onlyOwner {
}
function setMintPrice(uint256 _price) public onlyOwner {
}
function isWhiteList(address _user)public view returns(bool){
}
function freeMint(address _user) public callerIsUser nonReentrant {
uint256 supply = totalSupply();
require(!publicMintOpen, "no mint time");
require(supply + 1 <= maxTotal, "Exceeds maximum supply");
require(<FILL_ME>)
_safeMint(msg.sender, 1);
whiteLists[_user] = false;
}
function setOpenPublicMint() public onlyOwner {
}
function publicMint(uint256 num) public payable callerIsUser nonReentrant {
}
function setWithdrawAddress(address _withdrawAddress) public onlyOwner {
}
function withdraw() public onlyOwner callerIsUser nonReentrant {
}
function setBaseURI(string memory _baseTokenURI) public onlyOwner {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
modifier callerIsUser() {
}
}
| whiteLists[_user],"Not whiteLists user" | 506,084 | whiteLists[_user] |
"CoreRef: Caller is not a governor or contract admin" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./ICoreRef.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/// @title A Reference to Core
/// @author Fei Protocol
/// @notice defines some modifiers and utilities around interacting with Core
abstract contract CoreRef is ICoreRef, Pausable {
ICore private immutable _core;
IFei private immutable _fei;
IERC20 private immutable _tribe;
/// @notice a role used with a subset of governor permissions for this contract only
bytes32 public override CONTRACT_ADMIN_ROLE;
constructor(address coreAddress) {
}
function _initialize(address) internal {} // no-op for backward compatibility
modifier ifMinterSelf() {
}
modifier onlyMinter() {
}
modifier onlyBurner() {
}
modifier onlyPCVController() {
}
modifier onlyGovernorOrAdmin() {
require(<FILL_ME>)
_;
}
modifier onlyGovernor() {
}
modifier onlyGuardianOrGovernor() {
}
modifier isGovernorOrGuardianOrAdmin() {
}
// Named onlyTribeRole to prevent collision with OZ onlyRole modifier
modifier onlyTribeRole(bytes32 role) {
}
// Modifiers to allow any combination of roles
modifier hasAnyOfTwoRoles(bytes32 role1, bytes32 role2) {
}
modifier hasAnyOfThreeRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
modifier hasAnyOfFourRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4
) {
}
modifier hasAnyOfFiveRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5
) {
}
modifier hasAnyOfSixRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5,
bytes32 role6
) {
}
modifier onlyFei() {
}
/// @notice sets a new admin role for this contract
function setContractAdminRole(bytes32 newContractAdminRole) external override onlyGovernor {
}
/// @notice returns whether a given address has the admin role for this contract
function isContractAdmin(address _admin) public view override returns (bool) {
}
/// @notice set pausable methods to paused
function pause() public override onlyGuardianOrGovernor {
}
/// @notice set pausable methods to unpaused
function unpause() public override onlyGuardianOrGovernor {
}
/// @notice address of the Core contract referenced
/// @return ICore implementation address
function core() public view override returns (ICore) {
}
/// @notice address of the Fei contract referenced by Core
/// @return IFei implementation address
function fei() public view override returns (IFei) {
}
/// @notice address of the Tribe contract referenced by Core
/// @return IERC20 implementation address
function tribe() public view override returns (IERC20) {
}
/// @notice fei balance of contract
/// @return fei amount held
function feiBalance() public view override returns (uint256) {
}
/// @notice tribe balance of contract
/// @return tribe amount held
function tribeBalance() public view override returns (uint256) {
}
function _burnFeiHeld() internal {
}
function _mintFei(address to, uint256 amount) internal virtual {
}
function _setContractAdminRole(bytes32 newContractAdminRole) internal {
}
}
| _core.isGovernor(msg.sender)||isContractAdmin(msg.sender),"CoreRef: Caller is not a governor or contract admin" | 506,099 | _core.isGovernor(msg.sender)||isContractAdmin(msg.sender) |
"CoreRef: Caller is not governor or guardian or admin" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./ICoreRef.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/// @title A Reference to Core
/// @author Fei Protocol
/// @notice defines some modifiers and utilities around interacting with Core
abstract contract CoreRef is ICoreRef, Pausable {
ICore private immutable _core;
IFei private immutable _fei;
IERC20 private immutable _tribe;
/// @notice a role used with a subset of governor permissions for this contract only
bytes32 public override CONTRACT_ADMIN_ROLE;
constructor(address coreAddress) {
}
function _initialize(address) internal {} // no-op for backward compatibility
modifier ifMinterSelf() {
}
modifier onlyMinter() {
}
modifier onlyBurner() {
}
modifier onlyPCVController() {
}
modifier onlyGovernorOrAdmin() {
}
modifier onlyGovernor() {
}
modifier onlyGuardianOrGovernor() {
}
modifier isGovernorOrGuardianOrAdmin() {
require(<FILL_ME>)
_;
}
// Named onlyTribeRole to prevent collision with OZ onlyRole modifier
modifier onlyTribeRole(bytes32 role) {
}
// Modifiers to allow any combination of roles
modifier hasAnyOfTwoRoles(bytes32 role1, bytes32 role2) {
}
modifier hasAnyOfThreeRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
modifier hasAnyOfFourRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4
) {
}
modifier hasAnyOfFiveRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5
) {
}
modifier hasAnyOfSixRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5,
bytes32 role6
) {
}
modifier onlyFei() {
}
/// @notice sets a new admin role for this contract
function setContractAdminRole(bytes32 newContractAdminRole) external override onlyGovernor {
}
/// @notice returns whether a given address has the admin role for this contract
function isContractAdmin(address _admin) public view override returns (bool) {
}
/// @notice set pausable methods to paused
function pause() public override onlyGuardianOrGovernor {
}
/// @notice set pausable methods to unpaused
function unpause() public override onlyGuardianOrGovernor {
}
/// @notice address of the Core contract referenced
/// @return ICore implementation address
function core() public view override returns (ICore) {
}
/// @notice address of the Fei contract referenced by Core
/// @return IFei implementation address
function fei() public view override returns (IFei) {
}
/// @notice address of the Tribe contract referenced by Core
/// @return IERC20 implementation address
function tribe() public view override returns (IERC20) {
}
/// @notice fei balance of contract
/// @return fei amount held
function feiBalance() public view override returns (uint256) {
}
/// @notice tribe balance of contract
/// @return tribe amount held
function tribeBalance() public view override returns (uint256) {
}
function _burnFeiHeld() internal {
}
function _mintFei(address to, uint256 amount) internal virtual {
}
function _setContractAdminRole(bytes32 newContractAdminRole) internal {
}
}
| _core.isGovernor(msg.sender)||_core.isGuardian(msg.sender)||isContractAdmin(msg.sender),"CoreRef: Caller is not governor or guardian or admin" | 506,099 | _core.isGovernor(msg.sender)||_core.isGuardian(msg.sender)||isContractAdmin(msg.sender) |
"UNAUTHORIZED" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./ICoreRef.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/// @title A Reference to Core
/// @author Fei Protocol
/// @notice defines some modifiers and utilities around interacting with Core
abstract contract CoreRef is ICoreRef, Pausable {
ICore private immutable _core;
IFei private immutable _fei;
IERC20 private immutable _tribe;
/// @notice a role used with a subset of governor permissions for this contract only
bytes32 public override CONTRACT_ADMIN_ROLE;
constructor(address coreAddress) {
}
function _initialize(address) internal {} // no-op for backward compatibility
modifier ifMinterSelf() {
}
modifier onlyMinter() {
}
modifier onlyBurner() {
}
modifier onlyPCVController() {
}
modifier onlyGovernorOrAdmin() {
}
modifier onlyGovernor() {
}
modifier onlyGuardianOrGovernor() {
}
modifier isGovernorOrGuardianOrAdmin() {
}
// Named onlyTribeRole to prevent collision with OZ onlyRole modifier
modifier onlyTribeRole(bytes32 role) {
require(<FILL_ME>)
_;
}
// Modifiers to allow any combination of roles
modifier hasAnyOfTwoRoles(bytes32 role1, bytes32 role2) {
}
modifier hasAnyOfThreeRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
modifier hasAnyOfFourRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4
) {
}
modifier hasAnyOfFiveRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5
) {
}
modifier hasAnyOfSixRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5,
bytes32 role6
) {
}
modifier onlyFei() {
}
/// @notice sets a new admin role for this contract
function setContractAdminRole(bytes32 newContractAdminRole) external override onlyGovernor {
}
/// @notice returns whether a given address has the admin role for this contract
function isContractAdmin(address _admin) public view override returns (bool) {
}
/// @notice set pausable methods to paused
function pause() public override onlyGuardianOrGovernor {
}
/// @notice set pausable methods to unpaused
function unpause() public override onlyGuardianOrGovernor {
}
/// @notice address of the Core contract referenced
/// @return ICore implementation address
function core() public view override returns (ICore) {
}
/// @notice address of the Fei contract referenced by Core
/// @return IFei implementation address
function fei() public view override returns (IFei) {
}
/// @notice address of the Tribe contract referenced by Core
/// @return IERC20 implementation address
function tribe() public view override returns (IERC20) {
}
/// @notice fei balance of contract
/// @return fei amount held
function feiBalance() public view override returns (uint256) {
}
/// @notice tribe balance of contract
/// @return tribe amount held
function tribeBalance() public view override returns (uint256) {
}
function _burnFeiHeld() internal {
}
function _mintFei(address to, uint256 amount) internal virtual {
}
function _setContractAdminRole(bytes32 newContractAdminRole) internal {
}
}
| _core.hasRole(role,msg.sender),"UNAUTHORIZED" | 506,099 | _core.hasRole(role,msg.sender) |
"UNAUTHORIZED" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./ICoreRef.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/// @title A Reference to Core
/// @author Fei Protocol
/// @notice defines some modifiers and utilities around interacting with Core
abstract contract CoreRef is ICoreRef, Pausable {
ICore private immutable _core;
IFei private immutable _fei;
IERC20 private immutable _tribe;
/// @notice a role used with a subset of governor permissions for this contract only
bytes32 public override CONTRACT_ADMIN_ROLE;
constructor(address coreAddress) {
}
function _initialize(address) internal {} // no-op for backward compatibility
modifier ifMinterSelf() {
}
modifier onlyMinter() {
}
modifier onlyBurner() {
}
modifier onlyPCVController() {
}
modifier onlyGovernorOrAdmin() {
}
modifier onlyGovernor() {
}
modifier onlyGuardianOrGovernor() {
}
modifier isGovernorOrGuardianOrAdmin() {
}
// Named onlyTribeRole to prevent collision with OZ onlyRole modifier
modifier onlyTribeRole(bytes32 role) {
}
// Modifiers to allow any combination of roles
modifier hasAnyOfTwoRoles(bytes32 role1, bytes32 role2) {
require(<FILL_ME>)
_;
}
modifier hasAnyOfThreeRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
modifier hasAnyOfFourRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4
) {
}
modifier hasAnyOfFiveRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5
) {
}
modifier hasAnyOfSixRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5,
bytes32 role6
) {
}
modifier onlyFei() {
}
/// @notice sets a new admin role for this contract
function setContractAdminRole(bytes32 newContractAdminRole) external override onlyGovernor {
}
/// @notice returns whether a given address has the admin role for this contract
function isContractAdmin(address _admin) public view override returns (bool) {
}
/// @notice set pausable methods to paused
function pause() public override onlyGuardianOrGovernor {
}
/// @notice set pausable methods to unpaused
function unpause() public override onlyGuardianOrGovernor {
}
/// @notice address of the Core contract referenced
/// @return ICore implementation address
function core() public view override returns (ICore) {
}
/// @notice address of the Fei contract referenced by Core
/// @return IFei implementation address
function fei() public view override returns (IFei) {
}
/// @notice address of the Tribe contract referenced by Core
/// @return IERC20 implementation address
function tribe() public view override returns (IERC20) {
}
/// @notice fei balance of contract
/// @return fei amount held
function feiBalance() public view override returns (uint256) {
}
/// @notice tribe balance of contract
/// @return tribe amount held
function tribeBalance() public view override returns (uint256) {
}
function _burnFeiHeld() internal {
}
function _mintFei(address to, uint256 amount) internal virtual {
}
function _setContractAdminRole(bytes32 newContractAdminRole) internal {
}
}
| _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender),"UNAUTHORIZED" | 506,099 | _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender) |
"UNAUTHORIZED" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./ICoreRef.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/// @title A Reference to Core
/// @author Fei Protocol
/// @notice defines some modifiers and utilities around interacting with Core
abstract contract CoreRef is ICoreRef, Pausable {
ICore private immutable _core;
IFei private immutable _fei;
IERC20 private immutable _tribe;
/// @notice a role used with a subset of governor permissions for this contract only
bytes32 public override CONTRACT_ADMIN_ROLE;
constructor(address coreAddress) {
}
function _initialize(address) internal {} // no-op for backward compatibility
modifier ifMinterSelf() {
}
modifier onlyMinter() {
}
modifier onlyBurner() {
}
modifier onlyPCVController() {
}
modifier onlyGovernorOrAdmin() {
}
modifier onlyGovernor() {
}
modifier onlyGuardianOrGovernor() {
}
modifier isGovernorOrGuardianOrAdmin() {
}
// Named onlyTribeRole to prevent collision with OZ onlyRole modifier
modifier onlyTribeRole(bytes32 role) {
}
// Modifiers to allow any combination of roles
modifier hasAnyOfTwoRoles(bytes32 role1, bytes32 role2) {
}
modifier hasAnyOfThreeRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
require(<FILL_ME>)
_;
}
modifier hasAnyOfFourRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4
) {
}
modifier hasAnyOfFiveRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5
) {
}
modifier hasAnyOfSixRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5,
bytes32 role6
) {
}
modifier onlyFei() {
}
/// @notice sets a new admin role for this contract
function setContractAdminRole(bytes32 newContractAdminRole) external override onlyGovernor {
}
/// @notice returns whether a given address has the admin role for this contract
function isContractAdmin(address _admin) public view override returns (bool) {
}
/// @notice set pausable methods to paused
function pause() public override onlyGuardianOrGovernor {
}
/// @notice set pausable methods to unpaused
function unpause() public override onlyGuardianOrGovernor {
}
/// @notice address of the Core contract referenced
/// @return ICore implementation address
function core() public view override returns (ICore) {
}
/// @notice address of the Fei contract referenced by Core
/// @return IFei implementation address
function fei() public view override returns (IFei) {
}
/// @notice address of the Tribe contract referenced by Core
/// @return IERC20 implementation address
function tribe() public view override returns (IERC20) {
}
/// @notice fei balance of contract
/// @return fei amount held
function feiBalance() public view override returns (uint256) {
}
/// @notice tribe balance of contract
/// @return tribe amount held
function tribeBalance() public view override returns (uint256) {
}
function _burnFeiHeld() internal {
}
function _mintFei(address to, uint256 amount) internal virtual {
}
function _setContractAdminRole(bytes32 newContractAdminRole) internal {
}
}
| _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender)||_core.hasRole(role3,msg.sender),"UNAUTHORIZED" | 506,099 | _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender)||_core.hasRole(role3,msg.sender) |
"UNAUTHORIZED" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./ICoreRef.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/// @title A Reference to Core
/// @author Fei Protocol
/// @notice defines some modifiers and utilities around interacting with Core
abstract contract CoreRef is ICoreRef, Pausable {
ICore private immutable _core;
IFei private immutable _fei;
IERC20 private immutable _tribe;
/// @notice a role used with a subset of governor permissions for this contract only
bytes32 public override CONTRACT_ADMIN_ROLE;
constructor(address coreAddress) {
}
function _initialize(address) internal {} // no-op for backward compatibility
modifier ifMinterSelf() {
}
modifier onlyMinter() {
}
modifier onlyBurner() {
}
modifier onlyPCVController() {
}
modifier onlyGovernorOrAdmin() {
}
modifier onlyGovernor() {
}
modifier onlyGuardianOrGovernor() {
}
modifier isGovernorOrGuardianOrAdmin() {
}
// Named onlyTribeRole to prevent collision with OZ onlyRole modifier
modifier onlyTribeRole(bytes32 role) {
}
// Modifiers to allow any combination of roles
modifier hasAnyOfTwoRoles(bytes32 role1, bytes32 role2) {
}
modifier hasAnyOfThreeRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
modifier hasAnyOfFourRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4
) {
require(<FILL_ME>)
_;
}
modifier hasAnyOfFiveRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5
) {
}
modifier hasAnyOfSixRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5,
bytes32 role6
) {
}
modifier onlyFei() {
}
/// @notice sets a new admin role for this contract
function setContractAdminRole(bytes32 newContractAdminRole) external override onlyGovernor {
}
/// @notice returns whether a given address has the admin role for this contract
function isContractAdmin(address _admin) public view override returns (bool) {
}
/// @notice set pausable methods to paused
function pause() public override onlyGuardianOrGovernor {
}
/// @notice set pausable methods to unpaused
function unpause() public override onlyGuardianOrGovernor {
}
/// @notice address of the Core contract referenced
/// @return ICore implementation address
function core() public view override returns (ICore) {
}
/// @notice address of the Fei contract referenced by Core
/// @return IFei implementation address
function fei() public view override returns (IFei) {
}
/// @notice address of the Tribe contract referenced by Core
/// @return IERC20 implementation address
function tribe() public view override returns (IERC20) {
}
/// @notice fei balance of contract
/// @return fei amount held
function feiBalance() public view override returns (uint256) {
}
/// @notice tribe balance of contract
/// @return tribe amount held
function tribeBalance() public view override returns (uint256) {
}
function _burnFeiHeld() internal {
}
function _mintFei(address to, uint256 amount) internal virtual {
}
function _setContractAdminRole(bytes32 newContractAdminRole) internal {
}
}
| _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender)||_core.hasRole(role3,msg.sender)||_core.hasRole(role4,msg.sender),"UNAUTHORIZED" | 506,099 | _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender)||_core.hasRole(role3,msg.sender)||_core.hasRole(role4,msg.sender) |
"UNAUTHORIZED" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./ICoreRef.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/// @title A Reference to Core
/// @author Fei Protocol
/// @notice defines some modifiers and utilities around interacting with Core
abstract contract CoreRef is ICoreRef, Pausable {
ICore private immutable _core;
IFei private immutable _fei;
IERC20 private immutable _tribe;
/// @notice a role used with a subset of governor permissions for this contract only
bytes32 public override CONTRACT_ADMIN_ROLE;
constructor(address coreAddress) {
}
function _initialize(address) internal {} // no-op for backward compatibility
modifier ifMinterSelf() {
}
modifier onlyMinter() {
}
modifier onlyBurner() {
}
modifier onlyPCVController() {
}
modifier onlyGovernorOrAdmin() {
}
modifier onlyGovernor() {
}
modifier onlyGuardianOrGovernor() {
}
modifier isGovernorOrGuardianOrAdmin() {
}
// Named onlyTribeRole to prevent collision with OZ onlyRole modifier
modifier onlyTribeRole(bytes32 role) {
}
// Modifiers to allow any combination of roles
modifier hasAnyOfTwoRoles(bytes32 role1, bytes32 role2) {
}
modifier hasAnyOfThreeRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
modifier hasAnyOfFourRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4
) {
}
modifier hasAnyOfFiveRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5
) {
require(<FILL_ME>)
_;
}
modifier hasAnyOfSixRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5,
bytes32 role6
) {
}
modifier onlyFei() {
}
/// @notice sets a new admin role for this contract
function setContractAdminRole(bytes32 newContractAdminRole) external override onlyGovernor {
}
/// @notice returns whether a given address has the admin role for this contract
function isContractAdmin(address _admin) public view override returns (bool) {
}
/// @notice set pausable methods to paused
function pause() public override onlyGuardianOrGovernor {
}
/// @notice set pausable methods to unpaused
function unpause() public override onlyGuardianOrGovernor {
}
/// @notice address of the Core contract referenced
/// @return ICore implementation address
function core() public view override returns (ICore) {
}
/// @notice address of the Fei contract referenced by Core
/// @return IFei implementation address
function fei() public view override returns (IFei) {
}
/// @notice address of the Tribe contract referenced by Core
/// @return IERC20 implementation address
function tribe() public view override returns (IERC20) {
}
/// @notice fei balance of contract
/// @return fei amount held
function feiBalance() public view override returns (uint256) {
}
/// @notice tribe balance of contract
/// @return tribe amount held
function tribeBalance() public view override returns (uint256) {
}
function _burnFeiHeld() internal {
}
function _mintFei(address to, uint256 amount) internal virtual {
}
function _setContractAdminRole(bytes32 newContractAdminRole) internal {
}
}
| _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender)||_core.hasRole(role3,msg.sender)||_core.hasRole(role4,msg.sender)||_core.hasRole(role5,msg.sender),"UNAUTHORIZED" | 506,099 | _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender)||_core.hasRole(role3,msg.sender)||_core.hasRole(role4,msg.sender)||_core.hasRole(role5,msg.sender) |
"UNAUTHORIZED" | // SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.4;
import "./ICoreRef.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
/// @title A Reference to Core
/// @author Fei Protocol
/// @notice defines some modifiers and utilities around interacting with Core
abstract contract CoreRef is ICoreRef, Pausable {
ICore private immutable _core;
IFei private immutable _fei;
IERC20 private immutable _tribe;
/// @notice a role used with a subset of governor permissions for this contract only
bytes32 public override CONTRACT_ADMIN_ROLE;
constructor(address coreAddress) {
}
function _initialize(address) internal {} // no-op for backward compatibility
modifier ifMinterSelf() {
}
modifier onlyMinter() {
}
modifier onlyBurner() {
}
modifier onlyPCVController() {
}
modifier onlyGovernorOrAdmin() {
}
modifier onlyGovernor() {
}
modifier onlyGuardianOrGovernor() {
}
modifier isGovernorOrGuardianOrAdmin() {
}
// Named onlyTribeRole to prevent collision with OZ onlyRole modifier
modifier onlyTribeRole(bytes32 role) {
}
// Modifiers to allow any combination of roles
modifier hasAnyOfTwoRoles(bytes32 role1, bytes32 role2) {
}
modifier hasAnyOfThreeRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3
) {
}
modifier hasAnyOfFourRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4
) {
}
modifier hasAnyOfFiveRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5
) {
}
modifier hasAnyOfSixRoles(
bytes32 role1,
bytes32 role2,
bytes32 role3,
bytes32 role4,
bytes32 role5,
bytes32 role6
) {
require(<FILL_ME>)
_;
}
modifier onlyFei() {
}
/// @notice sets a new admin role for this contract
function setContractAdminRole(bytes32 newContractAdminRole) external override onlyGovernor {
}
/// @notice returns whether a given address has the admin role for this contract
function isContractAdmin(address _admin) public view override returns (bool) {
}
/// @notice set pausable methods to paused
function pause() public override onlyGuardianOrGovernor {
}
/// @notice set pausable methods to unpaused
function unpause() public override onlyGuardianOrGovernor {
}
/// @notice address of the Core contract referenced
/// @return ICore implementation address
function core() public view override returns (ICore) {
}
/// @notice address of the Fei contract referenced by Core
/// @return IFei implementation address
function fei() public view override returns (IFei) {
}
/// @notice address of the Tribe contract referenced by Core
/// @return IERC20 implementation address
function tribe() public view override returns (IERC20) {
}
/// @notice fei balance of contract
/// @return fei amount held
function feiBalance() public view override returns (uint256) {
}
/// @notice tribe balance of contract
/// @return tribe amount held
function tribeBalance() public view override returns (uint256) {
}
function _burnFeiHeld() internal {
}
function _mintFei(address to, uint256 amount) internal virtual {
}
function _setContractAdminRole(bytes32 newContractAdminRole) internal {
}
}
| _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender)||_core.hasRole(role3,msg.sender)||_core.hasRole(role4,msg.sender)||_core.hasRole(role5,msg.sender)||_core.hasRole(role6,msg.sender),"UNAUTHORIZED" | 506,099 | _core.hasRole(role1,msg.sender)||_core.hasRole(role2,msg.sender)||_core.hasRole(role3,msg.sender)||_core.hasRole(role4,msg.sender)||_core.hasRole(role5,msg.sender)||_core.hasRole(role6,msg.sender) |
"ERC20 operation did not succeed" | // SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/math/SafeMath.sol";
import "../interfaces/WrappedPiErc20Interface.sol";
import "../interfaces/IRouterConnector.sol";
/**
* @notice Connectors execute staking strategies by calling from PowerIndexRouter with delegatecall. Therefore,
* connector contracts should not have any rights stored in other contracts. Instead, rights for connector logic
* must be provided to PowerIndexRouter by proxy pattern, where the router is a proxy, and the connectors are
* implementations. Every connector implementation has unique staking logic for stake, redeem, beforePoke, and
* afterPoke functions, that returns data to save in PowerIndexRouter storage because connectors don't have any
* storage.
*/
abstract contract AbstractConnector is IRouterConnector {
using SafeMath for uint256;
uint256 public constant DEGRADATION_COEFFICIENT = 1 ether;
uint256 public constant HUNDRED_PCT = 1 ether;
uint256 public immutable LOCKED_PROFIT_DEGRADATION;
event Stake(address indexed sender, address indexed staking, address indexed underlying, uint256 amount);
event Redeem(address indexed sender, address indexed staking, address indexed underlying, uint256 amount);
event DistributeReward(
address indexed sender,
uint256 totalReward,
uint256 performanceFee,
uint256 piTokenReward,
uint256 lockedProfitBefore,
uint256 lockedProfitAfter
);
event DistributePerformanceFee(
uint256 performanceFeeDebtBefore,
uint256 performanceFeeDebtAfter,
uint256 underlyingBalance,
uint256 performance
);
constructor(uint256 _lockedProfitDegradation) public {
}
/**
* @notice Call external contract by piToken (piERC20) contract.
* @param _piToken piToken(piERC20) to call from.
* @param _contract Contract to call.
* @param _sig Function signature to call.
* @param _data Data of function arguments to call.
* @return Data returned from contract.
*/
function _callExternal(
WrappedPiErc20Interface _piToken,
address _contract,
bytes4 _sig,
bytes memory _data
) internal returns (bytes memory) {
}
/**
* @notice Distributes performance fee from reward and calculates locked profit.
* @param _distributeData Data is stored in the router contract and passed to the connector's functions.
* @param _piToken piToken(piERC20) address.
* @param _token ERC20 Token address to distribute reward.
* @param _totalReward Total reward received
* @return lockedProfitReward Rewards that locked in vesting.
* @return stakeData Result packed rewards data.
*/
function _distributeReward(
DistributeData memory _distributeData,
WrappedPiErc20Interface _piToken,
IERC20 _token,
uint256 _totalReward
) internal returns (uint256 lockedProfitReward, bytes memory stakeData) {
}
/**
* @notice Distributes performance fee from reward.
* @param _performanceFee Share of fee to subtract as performance fee.
* @param _performanceFeeReceiver Receiver of performance fee.
* @param _performanceFeeDebt Performance fee amount left from last distribution.
* @param _piToken piToken(piERC20).
* @param _underlying Underlying ERC20 token.
* @param _totalReward Total reward amount.
* @return performance Fee amount calculated to distribute.
* @return remainder Diff between total reward amount and performance fee.
* @return resultPerformanceFeeDebt Not yet distributed performance amount due to insufficient balance on
* piToken (piERC20).
*/
function _distributePerformanceFee(
uint256 _performanceFee,
address _performanceFeeReceiver,
uint256 _performanceFeeDebt,
WrappedPiErc20Interface _piToken,
IERC20 _underlying,
uint256 _totalReward
)
internal
returns (
uint256 performance,
uint256 remainder,
uint256 resultPerformanceFeeDebt
)
{
}
/**
* @notice Pack stake data to bytes.
*/
function packStakeData(
uint256 lockedProfit,
uint256 lastRewardDistribution,
uint256 performanceFeeDebt
) public pure returns (bytes memory) {
}
/**
* @notice Unpack stake data from bytes to variables.
*/
function unpackStakeData(bytes memory _stakeData)
public
pure
returns (
uint256 lockedProfit,
uint256 lastRewardDistribution,
uint256 performanceFeeDebt
)
{
}
/**
* @notice Calculate locked profit from packed _stakeData.
*/
function calculateLockedProfit(bytes memory _stakeData) external view override returns (uint256) {
}
/**
* @notice Calculate locked profit based on lastRewardDistribution timestamp.
* @param _lockedProfit Previous locked profit amount.
* @param _lastRewardDistribution Timestamp of last rewards distribution.
* @return Updated locked profit amount, calculated with past time from _lastRewardDistribution.
*/
function calculateLockedProfit(uint256 _lockedProfit, uint256 _lastRewardDistribution) public view returns (uint256) {
}
/**
* @notice Transfer token amount from piToken(piERC20) to destination.
* @param _piToken piToken(piERC20).
* @param _token ERC20 token address.
* @param _to Destination address.
* @param _value Amount to transfer.
*/
function _safeTransfer(
WrappedPiErc20Interface _piToken,
IERC20 _token,
address _to,
uint256 _value
) internal {
bytes memory response = _piToken.callExternal(
address(_token),
IERC20.transfer.selector,
abi.encode(_to, _value),
0
);
if (response.length > 0) {
// Return data is optional
require(<FILL_ME>)
}
}
function isClaimAvailable(
bytes calldata _claimParams, // solhint-disable-line
uint256 _lastClaimRewardsAt, // solhint-disable-line
uint256 _lastChangeStakeAt // solhint-disable-line
) external view virtual override returns (bool) {
}
}
| abi.decode(response,(bool)),"ERC20 operation did not succeed" | 506,126 | abi.decode(response,(bool)) |
"Must keep fees at 10% or less" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
/** This function will be used to generate the total supply
* while deploying the contract
*
* This function can never be called again after deploying contract
*/
function _tokengeneration(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
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 _setOwner(address newOwner) private {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract ArtoRias is ERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _interlock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
uint256 public tokenLiquidityThreshold = 1e5 * 10**18;
uint256 public maxBuyLimit = 1e6 * 10**18;
uint256 public maxSellLimit = 1e6 * 10**18;
uint256 public maxWalletLimit = 1e6 * 10**18;
uint256 public genesis_block;
uint256 private deadline = 1;
uint256 private launchtax = 99;
address public marketingWallet = 0xF8b248a3f9FdAb05c982B9B6799CdAc20AF76972;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
}
Taxes public taxes = Taxes(5, 0);
Taxes public sellTaxes = Taxes(5, 0);
uint256 public TotalBuyFee = taxes.marketing + taxes.liquidity;
uint256 public TotalSellFee = sellTaxes.marketing + sellTaxes.liquidity;
mapping(address => bool) public exemptFee;
mapping(address => bool) public isBlacklisted;
modifier lockTheSwap() {
}
constructor() ERC20("ArtoRias", "ARTO") {
}
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
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function Liquify(uint256 feeswap, Taxes memory swapTaxes) private lockTheSwap {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool state) external onlyOwner {
}
function updateLiquidityTreshhold(uint256 new_amount) external onlyOwner {
}
function Launch() external onlyOwner {
}
function updatedeadline(uint256 _deadline) external onlyOwner {
}
function updateIsBlacklisted(address account, bool state) external onlyOwner {
}
function bulkIsBlacklisted(address[] memory accounts, bool state) external onlyOwner {
}
function UpdateBuyTaxes(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
TotalBuyFee = _marketing + _liquidity ;
require(<FILL_ME>)
taxes = Taxes(_marketing,_liquidity);
}
function SetSellTaxes(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateExemptFee(address _address, bool state) external onlyOwner {
}
function bulkExemptFee(address[] memory accounts, bool state) external onlyOwner {
}
function updateMaxTxLimit(uint256 maxBuy, uint256 maxSell, uint256 maxWallet) external onlyOwner {
}
function rescueETH(uint256 weiAmount) external onlyOwner {
}
function rescueETHTokens(address tokenAdd, uint256 amount) external onlyOwner {
}
// fallbacks
receive() external payable {}
}
| (TotalBuyFee)<=10,"Must keep fees at 10% or less" | 506,305 | (TotalBuyFee)<=10 |
"Must keep fees at 10% or less" | //SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The defaut value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount)
public
virtual
override
returns (bool)
{
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender)
public
view
virtual
override
returns (uint256)
{
}
/**
* @dev See {IERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* Requirements:
*
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for ``sender``'s tokens of at least
* `amount`.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue)
public
virtual
returns (bool)
{
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue)
public
virtual
returns (bool)
{
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
/** This function will be used to generate the total supply
* while deploying the contract
*
* This function can never be called again after deploying contract
*/
function _tokengeneration(address account, uint256 amount) internal virtual {
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
library Address {
function sendValue(address payable recipient, uint256 amount) internal {
}
}
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 _setOwner(address newOwner) private {
}
}
interface IFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract ArtoRias is ERC20, Ownable {
using Address for address payable;
IRouter public router;
address public pair;
bool private _interlock = false;
bool public providingLiquidity = false;
bool public tradingEnabled = false;
uint256 public tokenLiquidityThreshold = 1e5 * 10**18;
uint256 public maxBuyLimit = 1e6 * 10**18;
uint256 public maxSellLimit = 1e6 * 10**18;
uint256 public maxWalletLimit = 1e6 * 10**18;
uint256 public genesis_block;
uint256 private deadline = 1;
uint256 private launchtax = 99;
address public marketingWallet = 0xF8b248a3f9FdAb05c982B9B6799CdAc20AF76972;
address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
}
Taxes public taxes = Taxes(5, 0);
Taxes public sellTaxes = Taxes(5, 0);
uint256 public TotalBuyFee = taxes.marketing + taxes.liquidity;
uint256 public TotalSellFee = sellTaxes.marketing + sellTaxes.liquidity;
mapping(address => bool) public exemptFee;
mapping(address => bool) public isBlacklisted;
modifier lockTheSwap() {
}
constructor() ERC20("ArtoRias", "ARTO") {
}
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
override
returns (bool)
{
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
override
returns (bool)
{
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function Liquify(uint256 feeswap, Taxes memory swapTaxes) private lockTheSwap {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool state) external onlyOwner {
}
function updateLiquidityTreshhold(uint256 new_amount) external onlyOwner {
}
function Launch() external onlyOwner {
}
function updatedeadline(uint256 _deadline) external onlyOwner {
}
function updateIsBlacklisted(address account, bool state) external onlyOwner {
}
function bulkIsBlacklisted(address[] memory accounts, bool state) external onlyOwner {
}
function UpdateBuyTaxes(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
}
function SetSellTaxes(
uint256 _marketing,
uint256 _liquidity
) external onlyOwner {
TotalSellFee = _marketing + _liquidity ;
require(<FILL_ME>)
sellTaxes = Taxes(_marketing,_liquidity);
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateExemptFee(address _address, bool state) external onlyOwner {
}
function bulkExemptFee(address[] memory accounts, bool state) external onlyOwner {
}
function updateMaxTxLimit(uint256 maxBuy, uint256 maxSell, uint256 maxWallet) external onlyOwner {
}
function rescueETH(uint256 weiAmount) external onlyOwner {
}
function rescueETHTokens(address tokenAdd, uint256 amount) external onlyOwner {
}
// fallbacks
receive() external payable {}
}
| (TotalSellFee)<=10,"Must keep fees at 10% or less" | 506,305 | (TotalSellFee)<=10 |
"wallet already claimed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
/*
* @title β Tigerbob
* @author β Matthew Wall
*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// βββββ β βββ //
// βββββ βββ βββββββββ βββ βββ βββ βββββ //
// ββββββββββ βββββββ βββββββ βββ ββββ ββββ ββ ββ ββββββ βββββ ββββ //
// ββββ ββ βββ βββ βββ ββββ βββ βββββββ βββ βββββββ ββββββ βββ //
// ββββ ββ βββββ βββββββββββ βββββββ βββββββββ βββ ββββββββ βββ βββββββ //
// ββββ ββββββ βββββββ βββββββ ββββββ ββββ β ββββ βββ ββ ββββ βββ ββββββ //
// ββββ ββββ ββ βββββ βββ ββ ββββββ ββββ ββββββββ βββ βββ ββ βββ βββββ //
// βββββββββ ββ ββββ βββββββ ββββ βββββββ β ββ //
// βββββ ββ ββββ //
// //
// //
// ββββββ βββββ βββββ //
// βββββ βββββββββββ βββββ βββββββββββ βββββ ββββββββββ //
// ββββββββββ β ββββ ββββββββββ β βββ βββββββββββ β ββββ //
// βββ ββββ βββββββββ βββββ βββ ββββββββββ ββββββ ββββ βββββββββ βββ //
// βββββ βββββββ βββββββ βββββββ ββββββββ ββββββββ βββββββ //
// ββββ β ββββ ββββββ ββ βββ ββββββ ββ ββββ βββ ββββββββ //
// β ββ βββββ βββββ ββββ βββββ βββββ ββ β βββββ ββββ βββββββββββ β //
// β βββββ ββββββββββββ ββ βββββ βββββββββββ ββ βββββ βββββββββββ β βββββββ βββ //
// βββββ ββ βββββββ β βββββ ββ βββββββ β βββββ β βββββββ β βββββββββββββ β //
// ββ ββββ ββββββββββ β ββ ββββ βββββββββ ββ ββ ββββ ββββββββββ ββ β βββ β //
// βββ ββββββ ββββββ βββββββ βββββββ ββββββ βββββ β ββββββ //
// βββββββ ββ β ββββ βββββββ ββ β ββββ βββββββ β ββ ββββ ββ //
// ββ βββ β βββββββ βββ ββ ββ βββββββ βββ ββ β βββββββ //
// βββ ββββββββ βββββ βββ ββββββββ βββββ ββ ββββββββ βββββ //
// βββββ βββββ ββββββββββ βββββ ββββ //
// β ββ ββ //
// //
// //
// //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
contract Tigerbob is ERC721A, Ownable {
using MerkleProof for bytes32[];
/* βββ PUBLIC VARIABLES βββ */
/*
* @notice β Control switch for sale
* @notice β Set by `setMintStage()`
* @dev β 0 = PAUSED; 1 = ALLOWLIST, 2 = WAITLIST
*/
enum MintStage {
PAUSED,
ALLOWLIST,
WAITLIST
}
MintStage public _stage = MintStage.PAUSED;
/*
* @notice β Mint price in ether
* @notice β Set by `setPrice()`
*/
uint256 public _price = 0.25 ether;
/*
* @notice β Allowlist start timestamp
* @notice β Set by `setAllowlistStartTimestamp()`
*/
uint256 public _allowlistStartTimestamp;
/*
* @notice β Allowlist end timestamp
* @notice β Set by `setAllowlistEndTimestamp()`
*/
uint256 public _allowlistEndTimestamp;
/*
* @notice β Waitlist start timestamp
* @notice β Set by `setWaitlistStartTimestamp()`
*/
uint256 public _waitlistStartTimestamp;
/*
* @notice β Waitlist end timestamp
* @notice β Set by `setWaitlistEndTimestamp()`
*/
uint256 public _waitlistEndTimestamp;
/*
* @notice β MerkleProof root for verifying allowlist addresses
* @notice β Set by `setRoot()`
*/
bytes32 public _root;
/*
* @notice β Address to the project's gnosis safe
* @notice β Set by `setSafe()`
*/
address payable public _safe =
payable(0x9a766555D4B815393a58e665909dd230b3745EFE);
/*
* @notice β Maximum token supply
* @dev β Note this is constant and cannot be changed
*/
uint256 public constant MAX_SUPPLY = 1_000;
/*
* @notice β Token URI base
* @notice β Passed into constructor and also can be set by `setBaseURI()`
*/
string public baseTokenURI;
/* βββ END PUBLIC VARIABLES βββ */
/* βββ INTERNAL FUNCTIONS βββ */
/*
* @notice β Internal function that overrides baseURI standard
* @return β Returns newly set baseTokenURI
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/* βββ END INTERNAL FUNCTIONS βββ */
/* βββ CONSTRUCTOR βββ */
/*
* @notice β Contract constructor
* @param - newBaseURI : Token base string for metadata
* @param β allowlistStartTimestamp: Timestamp that allowlist starts on
* @param β allowlistEndTimestamp: Timestamp that allowlist ends on
* @param β waitlistStartTimestamp: Timestamp that waitlist starts on
* @param β waitlistEndTimestamp: Timestamp that waitlist ends on
*/
constructor(
string memory newBaseURI,
uint256 allowlistStartTimestamp,
uint256 allowlistEndTimestamp,
uint256 waitlistStartTimestamp,
uint256 waitlistEndTimestamp
) ERC721A("Tigerbob", "TGRBOB") {
}
/* βββ END CONSTRUCTOR βββ */
/* βββ MODIFIERS βββ */
/*
* @notice β Smart contract source check
*/
modifier contractCheck() {
}
/*
* @notice β Current mint stage check
*/
modifier checkSaleActive() {
}
/*
* @notice β Token max supply boundary check
*/
modifier checkMaxSupply(uint256 _amount) {
}
/*
* @notice β Transaction value check
*/
modifier checkTxnValue() {
}
/*
* @notice β Validates the merkleproof data
*/
modifier validateProof(bytes32[] calldata _proof) {
require(<FILL_ME>)
require(
MerkleProof.verify(
_proof,
_root,
keccak256(abi.encodePacked(msg.sender))
),
"wallet not allowed"
);
_;
}
/* βββ END MODIFIERS βββ */
/* βββ OWNER FUNCTIONS βββ */
/*
* @notice β Gifts an amount of tokens to a given address
* @param β _to: Address to send the tokens to
* @param β _amount: Amount of tokens to send
*/
function gift(address _to, uint256 _amount)
public
onlyOwner
checkMaxSupply(_amount)
{
}
/*
* @notice β Sets the merkle root
* @param β _newRoot: New root to set
*/
function setRoot(bytes32 _newRoot) public onlyOwner {
}
/*
* @notice β Sets the Gnosis safe address
* @param β _newSafe: New address for the team safe
*/
function setSafe(address payable _newSafe) public onlyOwner {
}
/*
* @notice β Sets the mint price (in wei)
* @param β _newPrice: New mint price to set
*/
function setPrice(uint256 _newPrice) public onlyOwner {
}
/*
* @notice β Sets the allowlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setAllowlistStartTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the allowlist end timestamp
* @param β _newTime: New timestamp to set
*/
function setAllowlistEndTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the waitlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setWaitlistStartTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the waitlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setWaitlistEndTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the mint stage
* @param β _stage: {0 = PAUSED | 1 = ALLOWLIST | 2 = WAITLIST}
*/
function setMintStage(MintStage _newStage) public onlyOwner {
}
/*
* @notice β Sets the base URI to the given string
* @param β baseURI: New base URI to set
*/
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* @notice β Withdraws the contract balance to the safe
*/
function withdrawToSafe() public onlyOwner {
}
/*
* @notice β Withdraws the contract balance to the safe
*/
function withdrawToAny(address payable dest, uint256 amount)
public
onlyOwner
{
}
/* βββ END OWNER FUNCTIONS βββ */
/* βββ PUBLIC FUNCTIONS βββ */
/*
* @notice β Mint function
* @param _proof: MerkleProof data to validate
*/
function mint(bytes32[] calldata _proof)
public
payable
contractCheck
checkSaleActive
checkMaxSupply(1)
checkTxnValue
validateProof(_proof)
{
}
/* βββ END PUBLIC FUNCTIONS βββ */
}
| ERC721A._numberMinted(msg.sender)<1,"wallet already claimed" | 506,313 | ERC721A._numberMinted(msg.sender)<1 |
"wallet not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
/*
* @title β Tigerbob
* @author β Matthew Wall
*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// βββββ β βββ //
// βββββ βββ βββββββββ βββ βββ βββ βββββ //
// ββββββββββ βββββββ βββββββ βββ ββββ ββββ ββ ββ ββββββ βββββ ββββ //
// ββββ ββ βββ βββ βββ ββββ βββ βββββββ βββ βββββββ ββββββ βββ //
// ββββ ββ βββββ βββββββββββ βββββββ βββββββββ βββ ββββββββ βββ βββββββ //
// ββββ ββββββ βββββββ βββββββ ββββββ ββββ β ββββ βββ ββ ββββ βββ ββββββ //
// ββββ ββββ ββ βββββ βββ ββ ββββββ ββββ ββββββββ βββ βββ ββ βββ βββββ //
// βββββββββ ββ ββββ βββββββ ββββ βββββββ β ββ //
// βββββ ββ ββββ //
// //
// //
// ββββββ βββββ βββββ //
// βββββ βββββββββββ βββββ βββββββββββ βββββ ββββββββββ //
// ββββββββββ β ββββ ββββββββββ β βββ βββββββββββ β ββββ //
// βββ ββββ βββββββββ βββββ βββ ββββββββββ ββββββ ββββ βββββββββ βββ //
// βββββ βββββββ βββββββ βββββββ ββββββββ ββββββββ βββββββ //
// ββββ β ββββ ββββββ ββ βββ ββββββ ββ ββββ βββ ββββββββ //
// β ββ βββββ βββββ ββββ βββββ βββββ ββ β βββββ ββββ βββββββββββ β //
// β βββββ ββββββββββββ ββ βββββ βββββββββββ ββ βββββ βββββββββββ β βββββββ βββ //
// βββββ ββ βββββββ β βββββ ββ βββββββ β βββββ β βββββββ β βββββββββββββ β //
// ββ ββββ ββββββββββ β ββ ββββ βββββββββ ββ ββ ββββ ββββββββββ ββ β βββ β //
// βββ ββββββ ββββββ βββββββ βββββββ ββββββ βββββ β ββββββ //
// βββββββ ββ β ββββ βββββββ ββ β ββββ βββββββ β ββ ββββ ββ //
// ββ βββ β βββββββ βββ ββ ββ βββββββ βββ ββ β βββββββ //
// βββ ββββββββ βββββ βββ ββββββββ βββββ ββ ββββββββ βββββ //
// βββββ βββββ ββββββββββ βββββ ββββ //
// β ββ ββ //
// //
// //
// //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
contract Tigerbob is ERC721A, Ownable {
using MerkleProof for bytes32[];
/* βββ PUBLIC VARIABLES βββ */
/*
* @notice β Control switch for sale
* @notice β Set by `setMintStage()`
* @dev β 0 = PAUSED; 1 = ALLOWLIST, 2 = WAITLIST
*/
enum MintStage {
PAUSED,
ALLOWLIST,
WAITLIST
}
MintStage public _stage = MintStage.PAUSED;
/*
* @notice β Mint price in ether
* @notice β Set by `setPrice()`
*/
uint256 public _price = 0.25 ether;
/*
* @notice β Allowlist start timestamp
* @notice β Set by `setAllowlistStartTimestamp()`
*/
uint256 public _allowlistStartTimestamp;
/*
* @notice β Allowlist end timestamp
* @notice β Set by `setAllowlistEndTimestamp()`
*/
uint256 public _allowlistEndTimestamp;
/*
* @notice β Waitlist start timestamp
* @notice β Set by `setWaitlistStartTimestamp()`
*/
uint256 public _waitlistStartTimestamp;
/*
* @notice β Waitlist end timestamp
* @notice β Set by `setWaitlistEndTimestamp()`
*/
uint256 public _waitlistEndTimestamp;
/*
* @notice β MerkleProof root for verifying allowlist addresses
* @notice β Set by `setRoot()`
*/
bytes32 public _root;
/*
* @notice β Address to the project's gnosis safe
* @notice β Set by `setSafe()`
*/
address payable public _safe =
payable(0x9a766555D4B815393a58e665909dd230b3745EFE);
/*
* @notice β Maximum token supply
* @dev β Note this is constant and cannot be changed
*/
uint256 public constant MAX_SUPPLY = 1_000;
/*
* @notice β Token URI base
* @notice β Passed into constructor and also can be set by `setBaseURI()`
*/
string public baseTokenURI;
/* βββ END PUBLIC VARIABLES βββ */
/* βββ INTERNAL FUNCTIONS βββ */
/*
* @notice β Internal function that overrides baseURI standard
* @return β Returns newly set baseTokenURI
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/* βββ END INTERNAL FUNCTIONS βββ */
/* βββ CONSTRUCTOR βββ */
/*
* @notice β Contract constructor
* @param - newBaseURI : Token base string for metadata
* @param β allowlistStartTimestamp: Timestamp that allowlist starts on
* @param β allowlistEndTimestamp: Timestamp that allowlist ends on
* @param β waitlistStartTimestamp: Timestamp that waitlist starts on
* @param β waitlistEndTimestamp: Timestamp that waitlist ends on
*/
constructor(
string memory newBaseURI,
uint256 allowlistStartTimestamp,
uint256 allowlistEndTimestamp,
uint256 waitlistStartTimestamp,
uint256 waitlistEndTimestamp
) ERC721A("Tigerbob", "TGRBOB") {
}
/* βββ END CONSTRUCTOR βββ */
/* βββ MODIFIERS βββ */
/*
* @notice β Smart contract source check
*/
modifier contractCheck() {
}
/*
* @notice β Current mint stage check
*/
modifier checkSaleActive() {
}
/*
* @notice β Token max supply boundary check
*/
modifier checkMaxSupply(uint256 _amount) {
}
/*
* @notice β Transaction value check
*/
modifier checkTxnValue() {
}
/*
* @notice β Validates the merkleproof data
*/
modifier validateProof(bytes32[] calldata _proof) {
require(
ERC721A._numberMinted(msg.sender) < 1,
"wallet already claimed"
);
require(<FILL_ME>)
_;
}
/* βββ END MODIFIERS βββ */
/* βββ OWNER FUNCTIONS βββ */
/*
* @notice β Gifts an amount of tokens to a given address
* @param β _to: Address to send the tokens to
* @param β _amount: Amount of tokens to send
*/
function gift(address _to, uint256 _amount)
public
onlyOwner
checkMaxSupply(_amount)
{
}
/*
* @notice β Sets the merkle root
* @param β _newRoot: New root to set
*/
function setRoot(bytes32 _newRoot) public onlyOwner {
}
/*
* @notice β Sets the Gnosis safe address
* @param β _newSafe: New address for the team safe
*/
function setSafe(address payable _newSafe) public onlyOwner {
}
/*
* @notice β Sets the mint price (in wei)
* @param β _newPrice: New mint price to set
*/
function setPrice(uint256 _newPrice) public onlyOwner {
}
/*
* @notice β Sets the allowlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setAllowlistStartTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the allowlist end timestamp
* @param β _newTime: New timestamp to set
*/
function setAllowlistEndTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the waitlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setWaitlistStartTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the waitlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setWaitlistEndTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the mint stage
* @param β _stage: {0 = PAUSED | 1 = ALLOWLIST | 2 = WAITLIST}
*/
function setMintStage(MintStage _newStage) public onlyOwner {
}
/*
* @notice β Sets the base URI to the given string
* @param β baseURI: New base URI to set
*/
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* @notice β Withdraws the contract balance to the safe
*/
function withdrawToSafe() public onlyOwner {
}
/*
* @notice β Withdraws the contract balance to the safe
*/
function withdrawToAny(address payable dest, uint256 amount)
public
onlyOwner
{
}
/* βββ END OWNER FUNCTIONS βββ */
/* βββ PUBLIC FUNCTIONS βββ */
/*
* @notice β Mint function
* @param _proof: MerkleProof data to validate
*/
function mint(bytes32[] calldata _proof)
public
payable
contractCheck
checkSaleActive
checkMaxSupply(1)
checkTxnValue
validateProof(_proof)
{
}
/* βββ END PUBLIC FUNCTIONS βββ */
}
| MerkleProof.verify(_proof,_root,keccak256(abi.encodePacked(msg.sender))),"wallet not allowed" | 506,313 | MerkleProof.verify(_proof,_root,keccak256(abi.encodePacked(msg.sender))) |
"safe address not set" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
/*
* @title β Tigerbob
* @author β Matthew Wall
*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// βββββ β βββ //
// βββββ βββ βββββββββ βββ βββ βββ βββββ //
// ββββββββββ βββββββ βββββββ βββ ββββ ββββ ββ ββ ββββββ βββββ ββββ //
// ββββ ββ βββ βββ βββ ββββ βββ βββββββ βββ βββββββ ββββββ βββ //
// ββββ ββ βββββ βββββββββββ βββββββ βββββββββ βββ ββββββββ βββ βββββββ //
// ββββ ββββββ βββββββ βββββββ ββββββ ββββ β ββββ βββ ββ ββββ βββ ββββββ //
// ββββ ββββ ββ βββββ βββ ββ ββββββ ββββ ββββββββ βββ βββ ββ βββ βββββ //
// βββββββββ ββ ββββ βββββββ ββββ βββββββ β ββ //
// βββββ ββ ββββ //
// //
// //
// ββββββ βββββ βββββ //
// βββββ βββββββββββ βββββ βββββββββββ βββββ ββββββββββ //
// ββββββββββ β ββββ ββββββββββ β βββ βββββββββββ β ββββ //
// βββ ββββ βββββββββ βββββ βββ ββββββββββ ββββββ ββββ βββββββββ βββ //
// βββββ βββββββ βββββββ βββββββ ββββββββ ββββββββ βββββββ //
// ββββ β ββββ ββββββ ββ βββ ββββββ ββ ββββ βββ ββββββββ //
// β ββ βββββ βββββ ββββ βββββ βββββ ββ β βββββ ββββ βββββββββββ β //
// β βββββ ββββββββββββ ββ βββββ βββββββββββ ββ βββββ βββββββββββ β βββββββ βββ //
// βββββ ββ βββββββ β βββββ ββ βββββββ β βββββ β βββββββ β βββββββββββββ β //
// ββ ββββ ββββββββββ β ββ ββββ βββββββββ ββ ββ ββββ ββββββββββ ββ β βββ β //
// βββ ββββββ ββββββ βββββββ βββββββ ββββββ βββββ β ββββββ //
// βββββββ ββ β ββββ βββββββ ββ β ββββ βββββββ β ββ ββββ ββ //
// ββ βββ β βββββββ βββ ββ ββ βββββββ βββ ββ β βββββββ //
// βββ ββββββββ βββββ βββ ββββββββ βββββ ββ ββββββββ βββββ //
// βββββ βββββ ββββββββββ βββββ ββββ //
// β ββ ββ //
// //
// //
// //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
contract Tigerbob is ERC721A, Ownable {
using MerkleProof for bytes32[];
/* βββ PUBLIC VARIABLES βββ */
/*
* @notice β Control switch for sale
* @notice β Set by `setMintStage()`
* @dev β 0 = PAUSED; 1 = ALLOWLIST, 2 = WAITLIST
*/
enum MintStage {
PAUSED,
ALLOWLIST,
WAITLIST
}
MintStage public _stage = MintStage.PAUSED;
/*
* @notice β Mint price in ether
* @notice β Set by `setPrice()`
*/
uint256 public _price = 0.25 ether;
/*
* @notice β Allowlist start timestamp
* @notice β Set by `setAllowlistStartTimestamp()`
*/
uint256 public _allowlistStartTimestamp;
/*
* @notice β Allowlist end timestamp
* @notice β Set by `setAllowlistEndTimestamp()`
*/
uint256 public _allowlistEndTimestamp;
/*
* @notice β Waitlist start timestamp
* @notice β Set by `setWaitlistStartTimestamp()`
*/
uint256 public _waitlistStartTimestamp;
/*
* @notice β Waitlist end timestamp
* @notice β Set by `setWaitlistEndTimestamp()`
*/
uint256 public _waitlistEndTimestamp;
/*
* @notice β MerkleProof root for verifying allowlist addresses
* @notice β Set by `setRoot()`
*/
bytes32 public _root;
/*
* @notice β Address to the project's gnosis safe
* @notice β Set by `setSafe()`
*/
address payable public _safe =
payable(0x9a766555D4B815393a58e665909dd230b3745EFE);
/*
* @notice β Maximum token supply
* @dev β Note this is constant and cannot be changed
*/
uint256 public constant MAX_SUPPLY = 1_000;
/*
* @notice β Token URI base
* @notice β Passed into constructor and also can be set by `setBaseURI()`
*/
string public baseTokenURI;
/* βββ END PUBLIC VARIABLES βββ */
/* βββ INTERNAL FUNCTIONS βββ */
/*
* @notice β Internal function that overrides baseURI standard
* @return β Returns newly set baseTokenURI
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/* βββ END INTERNAL FUNCTIONS βββ */
/* βββ CONSTRUCTOR βββ */
/*
* @notice β Contract constructor
* @param - newBaseURI : Token base string for metadata
* @param β allowlistStartTimestamp: Timestamp that allowlist starts on
* @param β allowlistEndTimestamp: Timestamp that allowlist ends on
* @param β waitlistStartTimestamp: Timestamp that waitlist starts on
* @param β waitlistEndTimestamp: Timestamp that waitlist ends on
*/
constructor(
string memory newBaseURI,
uint256 allowlistStartTimestamp,
uint256 allowlistEndTimestamp,
uint256 waitlistStartTimestamp,
uint256 waitlistEndTimestamp
) ERC721A("Tigerbob", "TGRBOB") {
}
/* βββ END CONSTRUCTOR βββ */
/* βββ MODIFIERS βββ */
/*
* @notice β Smart contract source check
*/
modifier contractCheck() {
}
/*
* @notice β Current mint stage check
*/
modifier checkSaleActive() {
}
/*
* @notice β Token max supply boundary check
*/
modifier checkMaxSupply(uint256 _amount) {
}
/*
* @notice β Transaction value check
*/
modifier checkTxnValue() {
}
/*
* @notice β Validates the merkleproof data
*/
modifier validateProof(bytes32[] calldata _proof) {
}
/* βββ END MODIFIERS βββ */
/* βββ OWNER FUNCTIONS βββ */
/*
* @notice β Gifts an amount of tokens to a given address
* @param β _to: Address to send the tokens to
* @param β _amount: Amount of tokens to send
*/
function gift(address _to, uint256 _amount)
public
onlyOwner
checkMaxSupply(_amount)
{
}
/*
* @notice β Sets the merkle root
* @param β _newRoot: New root to set
*/
function setRoot(bytes32 _newRoot) public onlyOwner {
}
/*
* @notice β Sets the Gnosis safe address
* @param β _newSafe: New address for the team safe
*/
function setSafe(address payable _newSafe) public onlyOwner {
}
/*
* @notice β Sets the mint price (in wei)
* @param β _newPrice: New mint price to set
*/
function setPrice(uint256 _newPrice) public onlyOwner {
}
/*
* @notice β Sets the allowlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setAllowlistStartTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the allowlist end timestamp
* @param β _newTime: New timestamp to set
*/
function setAllowlistEndTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the waitlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setWaitlistStartTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the waitlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setWaitlistEndTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the mint stage
* @param β _stage: {0 = PAUSED | 1 = ALLOWLIST | 2 = WAITLIST}
*/
function setMintStage(MintStage _newStage) public onlyOwner {
}
/*
* @notice β Sets the base URI to the given string
* @param β baseURI: New base URI to set
*/
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* @notice β Withdraws the contract balance to the safe
*/
function withdrawToSafe() public onlyOwner {
require(<FILL_ME>)
_safe.transfer(address(this).balance);
}
/*
* @notice β Withdraws the contract balance to the safe
*/
function withdrawToAny(address payable dest, uint256 amount)
public
onlyOwner
{
}
/* βββ END OWNER FUNCTIONS βββ */
/* βββ PUBLIC FUNCTIONS βββ */
/*
* @notice β Mint function
* @param _proof: MerkleProof data to validate
*/
function mint(bytes32[] calldata _proof)
public
payable
contractCheck
checkSaleActive
checkMaxSupply(1)
checkTxnValue
validateProof(_proof)
{
}
/* βββ END PUBLIC FUNCTIONS βββ */
}
| address(_safe)!=address(0),"safe address not set" | 506,313 | address(_safe)!=address(0) |
"cannot withdraw to null address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "erc721a/contracts/ERC721A.sol";
/*
* @title β Tigerbob
* @author β Matthew Wall
*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// //
// //
// //
// βββββ β βββ //
// βββββ βββ βββββββββ βββ βββ βββ βββββ //
// ββββββββββ βββββββ βββββββ βββ ββββ ββββ ββ ββ ββββββ βββββ ββββ //
// ββββ ββ βββ βββ βββ ββββ βββ βββββββ βββ βββββββ ββββββ βββ //
// ββββ ββ βββββ βββββββββββ βββββββ βββββββββ βββ ββββββββ βββ βββββββ //
// ββββ ββββββ βββββββ βββββββ ββββββ ββββ β ββββ βββ ββ ββββ βββ ββββββ //
// ββββ ββββ ββ βββββ βββ ββ ββββββ ββββ ββββββββ βββ βββ ββ βββ βββββ //
// βββββββββ ββ ββββ βββββββ ββββ βββββββ β ββ //
// βββββ ββ ββββ //
// //
// //
// ββββββ βββββ βββββ //
// βββββ βββββββββββ βββββ βββββββββββ βββββ ββββββββββ //
// ββββββββββ β ββββ ββββββββββ β βββ βββββββββββ β ββββ //
// βββ ββββ βββββββββ βββββ βββ ββββββββββ ββββββ ββββ βββββββββ βββ //
// βββββ βββββββ βββββββ βββββββ ββββββββ ββββββββ βββββββ //
// ββββ β ββββ ββββββ ββ βββ ββββββ ββ ββββ βββ ββββββββ //
// β ββ βββββ βββββ ββββ βββββ βββββ ββ β βββββ ββββ βββββββββββ β //
// β βββββ ββββββββββββ ββ βββββ βββββββββββ ββ βββββ βββββββββββ β βββββββ βββ //
// βββββ ββ βββββββ β βββββ ββ βββββββ β βββββ β βββββββ β βββββββββββββ β //
// ββ ββββ ββββββββββ β ββ ββββ βββββββββ ββ ββ ββββ ββββββββββ ββ β βββ β //
// βββ ββββββ ββββββ βββββββ βββββββ ββββββ βββββ β ββββββ //
// βββββββ ββ β ββββ βββββββ ββ β ββββ βββββββ β ββ ββββ ββ //
// ββ βββ β βββββββ βββ ββ ββ βββββββ βββ ββ β βββββββ //
// βββ ββββββββ βββββ βββ ββββββββ βββββ ββ ββββββββ βββββ //
// βββββ βββββ ββββββββββ βββββ ββββ //
// β ββ ββ //
// //
// //
// //
// //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
contract Tigerbob is ERC721A, Ownable {
using MerkleProof for bytes32[];
/* βββ PUBLIC VARIABLES βββ */
/*
* @notice β Control switch for sale
* @notice β Set by `setMintStage()`
* @dev β 0 = PAUSED; 1 = ALLOWLIST, 2 = WAITLIST
*/
enum MintStage {
PAUSED,
ALLOWLIST,
WAITLIST
}
MintStage public _stage = MintStage.PAUSED;
/*
* @notice β Mint price in ether
* @notice β Set by `setPrice()`
*/
uint256 public _price = 0.25 ether;
/*
* @notice β Allowlist start timestamp
* @notice β Set by `setAllowlistStartTimestamp()`
*/
uint256 public _allowlistStartTimestamp;
/*
* @notice β Allowlist end timestamp
* @notice β Set by `setAllowlistEndTimestamp()`
*/
uint256 public _allowlistEndTimestamp;
/*
* @notice β Waitlist start timestamp
* @notice β Set by `setWaitlistStartTimestamp()`
*/
uint256 public _waitlistStartTimestamp;
/*
* @notice β Waitlist end timestamp
* @notice β Set by `setWaitlistEndTimestamp()`
*/
uint256 public _waitlistEndTimestamp;
/*
* @notice β MerkleProof root for verifying allowlist addresses
* @notice β Set by `setRoot()`
*/
bytes32 public _root;
/*
* @notice β Address to the project's gnosis safe
* @notice β Set by `setSafe()`
*/
address payable public _safe =
payable(0x9a766555D4B815393a58e665909dd230b3745EFE);
/*
* @notice β Maximum token supply
* @dev β Note this is constant and cannot be changed
*/
uint256 public constant MAX_SUPPLY = 1_000;
/*
* @notice β Token URI base
* @notice β Passed into constructor and also can be set by `setBaseURI()`
*/
string public baseTokenURI;
/* βββ END PUBLIC VARIABLES βββ */
/* βββ INTERNAL FUNCTIONS βββ */
/*
* @notice β Internal function that overrides baseURI standard
* @return β Returns newly set baseTokenURI
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/* βββ END INTERNAL FUNCTIONS βββ */
/* βββ CONSTRUCTOR βββ */
/*
* @notice β Contract constructor
* @param - newBaseURI : Token base string for metadata
* @param β allowlistStartTimestamp: Timestamp that allowlist starts on
* @param β allowlistEndTimestamp: Timestamp that allowlist ends on
* @param β waitlistStartTimestamp: Timestamp that waitlist starts on
* @param β waitlistEndTimestamp: Timestamp that waitlist ends on
*/
constructor(
string memory newBaseURI,
uint256 allowlistStartTimestamp,
uint256 allowlistEndTimestamp,
uint256 waitlistStartTimestamp,
uint256 waitlistEndTimestamp
) ERC721A("Tigerbob", "TGRBOB") {
}
/* βββ END CONSTRUCTOR βββ */
/* βββ MODIFIERS βββ */
/*
* @notice β Smart contract source check
*/
modifier contractCheck() {
}
/*
* @notice β Current mint stage check
*/
modifier checkSaleActive() {
}
/*
* @notice β Token max supply boundary check
*/
modifier checkMaxSupply(uint256 _amount) {
}
/*
* @notice β Transaction value check
*/
modifier checkTxnValue() {
}
/*
* @notice β Validates the merkleproof data
*/
modifier validateProof(bytes32[] calldata _proof) {
}
/* βββ END MODIFIERS βββ */
/* βββ OWNER FUNCTIONS βββ */
/*
* @notice β Gifts an amount of tokens to a given address
* @param β _to: Address to send the tokens to
* @param β _amount: Amount of tokens to send
*/
function gift(address _to, uint256 _amount)
public
onlyOwner
checkMaxSupply(_amount)
{
}
/*
* @notice β Sets the merkle root
* @param β _newRoot: New root to set
*/
function setRoot(bytes32 _newRoot) public onlyOwner {
}
/*
* @notice β Sets the Gnosis safe address
* @param β _newSafe: New address for the team safe
*/
function setSafe(address payable _newSafe) public onlyOwner {
}
/*
* @notice β Sets the mint price (in wei)
* @param β _newPrice: New mint price to set
*/
function setPrice(uint256 _newPrice) public onlyOwner {
}
/*
* @notice β Sets the allowlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setAllowlistStartTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the allowlist end timestamp
* @param β _newTime: New timestamp to set
*/
function setAllowlistEndTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the waitlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setWaitlistStartTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the waitlist start timestamp
* @param β _newTime: New timestamp to set
*/
function setWaitlistEndTimestamp(uint256 _newTime) public onlyOwner {
}
/*
* @notice β Sets the mint stage
* @param β _stage: {0 = PAUSED | 1 = ALLOWLIST | 2 = WAITLIST}
*/
function setMintStage(MintStage _newStage) public onlyOwner {
}
/*
* @notice β Sets the base URI to the given string
* @param β baseURI: New base URI to set
*/
function setBaseURI(string memory baseURI) public onlyOwner {
}
/*
* @notice β Withdraws the contract balance to the safe
*/
function withdrawToSafe() public onlyOwner {
}
/*
* @notice β Withdraws the contract balance to the safe
*/
function withdrawToAny(address payable dest, uint256 amount)
public
onlyOwner
{
require(<FILL_ME>)
require(amount > 0, "cannot withdraw zero amount");
dest.transfer(amount);
}
/* βββ END OWNER FUNCTIONS βββ */
/* βββ PUBLIC FUNCTIONS βββ */
/*
* @notice β Mint function
* @param _proof: MerkleProof data to validate
*/
function mint(bytes32[] calldata _proof)
public
payable
contractCheck
checkSaleActive
checkMaxSupply(1)
checkTxnValue
validateProof(_proof)
{
}
/* βββ END PUBLIC FUNCTIONS βββ */
}
| address(dest)!=address(0),"cannot withdraw to null address" | 506,313 | address(dest)!=address(0) |
"Partner address is repeated, please check again." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Buffer is Initializable, ReentrancyGuard {
uint256 public totalReceived;
uint256 private totalAmount;
struct ShareData {
uint256 shareAmount;
uint256 lastBlockNumber;
uint256 withdrawn;
}
address public curator;
uint256 private totalOwnersFee;
uint256 private totalCreatorsFee;
uint256 private totalPartnersFee;
uint256 public royaltyFee;
mapping(address => ShareData) public _shareData;
uint256 public totalShares;
uint256 public totalSharesOfPartners;
mapping(uint256 => address) private partnersGroup;
uint256 private partnersGroupLength = 0;
mapping(uint256 => address) private creatorsGroup;
uint256 private creatorsGroupLength = 0;
mapping(uint256 => uint256) private creatorPairInfo;
mapping(uint256 => address) private ownersGroup;
uint256 private ownersGroupLength = 0;
//////////
mapping(uint256 => uint256) public shareDetails;
uint256 private shareDetailLength = 0;
mapping(uint256 => uint256) public partnerShareDetails;
address private deadAddress = 0x0000000000000000000000000000000000000000;
uint256 private totalCntOfContent = 0;
//////////
address public marketWallet; // wallet address for market fee
address public owner;
modifier onlyOwner() {
}
event UpdateCreatorPairsCheck(bool updated);
event UpdateCreatorsGroupCheck(bool updateGroup);
event UpdateFeeCheck(uint256 feePercent);
event WithdrawnCheck(address to, uint256 amount);
event UpdateSharesCheck(uint256[] share, uint256[] partnerShare);
function initialize(
address _owner,
address _curator, // address for curator
address[] memory _partnersGroup, // array of address for partners group
address[] memory _creatorsGroup, // array of address for creators group
uint256[] calldata _shares, // array of share percentage for every group
uint256[] calldata _partnerShare, // array of share percentage for every members of partners group
address _marketWallet
) public payable initializer {
curator = _curator;
for (uint256 i = 0; i < _partnersGroup.length; i++) {
for (uint256 j = 0; j < i; j++) {
require(<FILL_ME>)
}
partnersGroup[i] = _partnersGroup[i];
partnersGroupLength++;
}
for (uint256 i = 0; i < _creatorsGroup.length; i++) {
for (uint256 j = 0; j < i; j++) {
require(
creatorsGroup[j] != _creatorsGroup[i],
"Creator address is repeated, please check again."
);
}
creatorsGroup[i] = _creatorsGroup[i];
creatorsGroupLength++;
}
require(_shares.length == 7, "Please input shares info correctly.");
for (uint256 i = 0; i < _shares.length - 1; i++) {
//////////
totalShares += _shares[i];
shareDetails[i] = _shares[i];
shareDetailLength++;
//////////
}
require(totalShares > 0, "Sum of share percentages must be greater than 0.");
require(
_partnersGroup.length == _partnerShare.length,
"Please input partner group shares information correctly."
);
for (uint256 i = 0; i < _partnerShare.length; i++) {
totalSharesOfPartners += _partnerShare[i];
//////////
partnerShareDetails[i] = _partnerShare[i];
//////////
}
marketWallet = _marketWallet;
owner = _owner;
royaltyFee = 10;
}
function transferOwnership(address _newOwner) external onlyOwner {
}
receive() external payable {
}
// Get the last block number
function getBlockNumber(address account) external view returns (uint256) {
}
function updateFeePercent(uint256 _royaltyFee) public onlyOwner {
}
function updateCreatorsGroupMint(address[] calldata _creatorsGroup) external onlyOwner {
}
// update creator pair info of creators addresses and tokenIDs of same lengths
function updateCreatorsGroup(address[] calldata _creatorsGroup, uint256[] calldata _numOfTokens) external onlyOwner {
}
function updateOwners(address[] calldata _owners) external onlyOwner {
}
function updateRoyaltyPercentage(uint256[] calldata _share, uint256[] calldata _partnerShare) external onlyOwner {
}
// Withdraw
function withdraw(
address account, // address to ask withdraw
address[] calldata sellerAddresses, // array of sellers address
uint256[] calldata tokenIDs, // array of tokenIDs to be sold
uint256[] calldata prices // array of prices of NFTs to be sold
) external nonReentrant {
}
// adopted from https://github.com/lexDAO/Kali/blob/main/contracts/libraries/SafeTransferLib.sol
error TransferFailed();
function _transfer(address to, uint256 amount) internal {
}
}
| partnersGroup[j]!=_partnersGroup[i],"Partner address is repeated, please check again." | 506,357 | partnersGroup[j]!=_partnersGroup[i] |
"Creator address is repeated, please check again." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract Buffer is Initializable, ReentrancyGuard {
uint256 public totalReceived;
uint256 private totalAmount;
struct ShareData {
uint256 shareAmount;
uint256 lastBlockNumber;
uint256 withdrawn;
}
address public curator;
uint256 private totalOwnersFee;
uint256 private totalCreatorsFee;
uint256 private totalPartnersFee;
uint256 public royaltyFee;
mapping(address => ShareData) public _shareData;
uint256 public totalShares;
uint256 public totalSharesOfPartners;
mapping(uint256 => address) private partnersGroup;
uint256 private partnersGroupLength = 0;
mapping(uint256 => address) private creatorsGroup;
uint256 private creatorsGroupLength = 0;
mapping(uint256 => uint256) private creatorPairInfo;
mapping(uint256 => address) private ownersGroup;
uint256 private ownersGroupLength = 0;
//////////
mapping(uint256 => uint256) public shareDetails;
uint256 private shareDetailLength = 0;
mapping(uint256 => uint256) public partnerShareDetails;
address private deadAddress = 0x0000000000000000000000000000000000000000;
uint256 private totalCntOfContent = 0;
//////////
address public marketWallet; // wallet address for market fee
address public owner;
modifier onlyOwner() {
}
event UpdateCreatorPairsCheck(bool updated);
event UpdateCreatorsGroupCheck(bool updateGroup);
event UpdateFeeCheck(uint256 feePercent);
event WithdrawnCheck(address to, uint256 amount);
event UpdateSharesCheck(uint256[] share, uint256[] partnerShare);
function initialize(
address _owner,
address _curator, // address for curator
address[] memory _partnersGroup, // array of address for partners group
address[] memory _creatorsGroup, // array of address for creators group
uint256[] calldata _shares, // array of share percentage for every group
uint256[] calldata _partnerShare, // array of share percentage for every members of partners group
address _marketWallet
) public payable initializer {
curator = _curator;
for (uint256 i = 0; i < _partnersGroup.length; i++) {
for (uint256 j = 0; j < i; j++) {
require(
partnersGroup[j] != _partnersGroup[i],
"Partner address is repeated, please check again."
);
}
partnersGroup[i] = _partnersGroup[i];
partnersGroupLength++;
}
for (uint256 i = 0; i < _creatorsGroup.length; i++) {
for (uint256 j = 0; j < i; j++) {
require(<FILL_ME>)
}
creatorsGroup[i] = _creatorsGroup[i];
creatorsGroupLength++;
}
require(_shares.length == 7, "Please input shares info correctly.");
for (uint256 i = 0; i < _shares.length - 1; i++) {
//////////
totalShares += _shares[i];
shareDetails[i] = _shares[i];
shareDetailLength++;
//////////
}
require(totalShares > 0, "Sum of share percentages must be greater than 0.");
require(
_partnersGroup.length == _partnerShare.length,
"Please input partner group shares information correctly."
);
for (uint256 i = 0; i < _partnerShare.length; i++) {
totalSharesOfPartners += _partnerShare[i];
//////////
partnerShareDetails[i] = _partnerShare[i];
//////////
}
marketWallet = _marketWallet;
owner = _owner;
royaltyFee = 10;
}
function transferOwnership(address _newOwner) external onlyOwner {
}
receive() external payable {
}
// Get the last block number
function getBlockNumber(address account) external view returns (uint256) {
}
function updateFeePercent(uint256 _royaltyFee) public onlyOwner {
}
function updateCreatorsGroupMint(address[] calldata _creatorsGroup) external onlyOwner {
}
// update creator pair info of creators addresses and tokenIDs of same lengths
function updateCreatorsGroup(address[] calldata _creatorsGroup, uint256[] calldata _numOfTokens) external onlyOwner {
}
function updateOwners(address[] calldata _owners) external onlyOwner {
}
function updateRoyaltyPercentage(uint256[] calldata _share, uint256[] calldata _partnerShare) external onlyOwner {
}
// Withdraw
function withdraw(
address account, // address to ask withdraw
address[] calldata sellerAddresses, // array of sellers address
uint256[] calldata tokenIDs, // array of tokenIDs to be sold
uint256[] calldata prices // array of prices of NFTs to be sold
) external nonReentrant {
}
// adopted from https://github.com/lexDAO/Kali/blob/main/contracts/libraries/SafeTransferLib.sol
error TransferFailed();
function _transfer(address to, uint256 amount) internal {
}
}
| creatorsGroup[j]!=_creatorsGroup[i],"Creator address is repeated, please check again." | 506,357 | creatorsGroup[j]!=_creatorsGroup[i] |
"This token was not created by GAS!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//////////////////////////////////////////////////////////////////////////////
// _____ __ ___ ____ ______ //
// / ___/__ ____ ___ ____ / /____ ____ / _ | / / / / __/ /____ _____ //
// / (_ / _ `/ _ \/ _ `(_-</ __/ -_) __/ / __ |/ / / _\ \/ __/ _ `/ __/ //
// \___/\_,_/_//_/\_, /___/\__/\__/_/ /_/ |_/_/_/ /___/\__/\_,_/_/ //
// /___/ //
// ____ ___ ___ //
// / __// _ \ / _ )___ ___ ___ ___ ___ //
// /__ \/ // / / _ / _ \(_-<(_-</ -_|_-< //
// /____/\___/ /____/\___/___/___/\__/___/ //
// //
// Migration by: 0xInuarashi //
// //
//////////////////////////////////////////////////////////////////////////////
contract ERC721I {
string public name; string public symbol;
string internal baseTokenURI; string internal baseTokenURI_EXT;
constructor(string memory name_, string memory symbol_) {
}
uint256 public totalSupply;
mapping(uint256 => address) public ownerOf;
mapping(address => uint256) public balanceOf;
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
// Events
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Mint(address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved,
uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator,
bool approved);
// // internal write functions
// mint
function _mint(address to_, uint256 tokenId_) internal virtual {
}
// transfer
function _transfer(address from_, address to_, uint256 tokenId_) internal virtual {
}
// approve
function _approve(address to_, uint256 tokenId_) internal virtual {
}
function _setApprovalForAll(address owner_, address operator_, bool approved_)
internal virtual {
}
// token uri
function _setBaseTokenURI(string memory uri_) internal virtual {
}
function _setBaseTokenURI_EXT(string memory ext_) internal virtual {
}
// // Internal View Functions
// Embedded Libraries
function _toString(uint256 value_) internal pure returns (string memory) {
}
// Functional Views
function _isApprovedOrOwner(address spender_, uint256 tokenId_) internal
view virtual returns (bool) {
}
function _exists(uint256 tokenId_) internal view virtual returns (bool) {
}
// // public write functions
function approve(address to_, uint256 tokenId_) public virtual {
}
function setApprovalForAll(address operator_, bool approved_) public virtual {
}
function transferFrom(address from_, address to_, uint256 tokenId_)
public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_,
bytes memory data_) public virtual {
}
function safeTransferFrom(address from_, address to_, uint256 tokenId_)
public virtual {
}
// 0xInuarashi Custom Functions
function multiTransferFrom(address from_, address to_, uint256[] memory tokenIds_)
public virtual {
}
function multiSafeTransferFrom(address from_, address to_,
uint256[] memory tokenIds_, bytes memory data_) public virtual {
}
// OZ Standard Stuff
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
}
function tokenURI(uint256 tokenId_) public view virtual returns (string memory) {
}
// // public view functions
// never use these for functions ever, they are expensive af and for view only
function walletOfOwner(address address_) public virtual view
returns (uint256[] memory) {
}
// not sure when this will ever be needed but it conforms to erc721 enumerable
function tokenOfOwnerByIndex(address address_, uint256 index_) public
virtual view returns (uint256) {
}
}
abstract contract Ownable {
address public owner;
constructor() { }
modifier onlyOwner { }
function transferOwnership(address new_) external onlyOwner { }
}
interface IERC1155 {
function safeTransferFrom(address from_, address to_, uint256 id_,
uint256 amount_, bytes calldata data_) external;
}
contract GangsterAllStarOG is ERC721I, Ownable {
constructor() ERC721I("Gangster All Star OG", "GAS OG") {}
// Migration Variables
address public constant burnAddress = 0x000000000000000000000000000000000000dEaD;
address public constant OSAddress = 0x495f947276749Ce646f68AC8c248420045cb7b5e;
IERC1155 public OSStore = IERC1155(OSAddress);
bool public migrationEnabled = true;
// Events
event Migrated(address migrator_, uint256 newTokenId_, uint256 oldTokenId_);
// Modifiers
modifier onlySender { }
modifier onlyMigration { }
// Administration
function setMigration(bool bool_) external onlyOwner {
}
function setBaseTokenURI(string calldata uri_) external onlyOwner {
}
function setBaseTokenURI_EXT(string calldata ext_) external onlyOwner {
}
// Token ID Finder
function getRawIdFromOS(uint256 tokenId_) public pure returns (uint256) {
}
function isCreatedByGAS(uint256 tokenId_) public pure returns (bool) {
}
function getTokenOffsets(uint256 tokenId_) public pure returns (uint256) {
}
function getValidOGTokenId(uint256 tokenId_) public pure returns (uint256) {
require(<FILL_ME>)
uint256 _rawId = getRawIdFromOS(tokenId_);
return _rawId - getTokenOffsets(_rawId);
}
// Migration Logic
function migrateGangster(uint256 tokenId_) external onlySender onlyMigration {
}
// Mint ID 19
function mintStuck(address to_) external onlyOwner {
}
}
| isCreatedByGAS(tokenId_),"This token was not created by GAS!" | 506,360 | isCreatedByGAS(tokenId_) |
"Cannot sell or transfer more than limit." | pragma solidity ^0.7.4;
contract HinasanInuV5 is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
uint8 public _decimals = 5;
IUniswapV2Pair public pairContract;
mapping(address => bool) _isFeeExempt;
modifier validRecipient(address to) {
}
uint256 public constant DECIMALS = 18;
//buy fees
uint256 public buyTreasuryFee = 40;
uint256 public buyLiquidityFee = 30;
uint256 public buyBurnerTokenFee = 20;
uint256 public totalBuyFee = buyTreasuryFee.add(buyBurnerTokenFee).add(buyLiquidityFee); // 9%
//sell fees
uint256 public sellTreasuryFee = 40;
uint256 public sellLiquidityFee = 30;
uint256 public sellBurnerTokenFee = 20;
uint256 public totalSellFee = sellTreasuryFee.add(sellLiquidityFee).add(sellBurnerTokenFee); // 9%
uint256 public feeDenominator = 1000;
//counters
uint256 internal buyTreasuryFeeAmount = 0;
uint256 internal buyBurnerTokenFeeAmount = 0;
uint256 internal buyLiquidityFeeAmount = 0;
uint256 internal sellTreasuryFeeAmount = 0;
uint256 internal sellLiquidityFeeAmount = 0;
uint256 internal sellBurnerTokenFeeAmount = 0;
//burnerToken
address[] tokens;
address activeToken = DEAD;
IERC20 activeTokenContract;
mapping (address => uint256) tokensBoughtAndBurned;
mapping (address => uint256) ethSpentOnToken;
uint256 totalEthSpent = 0;
uint256 public startTime;
uint256 public sellLimit = 25;
uint256 public holdLimit = 25;
uint256 public limitDenominator = 10000;
uint256 public constant TIME_STEP = 1 days;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver;
address public pairAddress;
bool public swapBackEnabled = true;
IUniswapV2Router02 public router;
address public pair;
bool inSwap = false;
modifier swapping() {
}
uint256 public _totalSupply = 1 * 10**9 * 10**DECIMALS;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public blacklist;
mapping(address => mapping(uint256 => uint256)) public sold;
mapping(address => bool) public _excludeFromLimit;
mapping(address => bool) public authorized;
bool public transferEnabled = false;
bool public autoAddLiquidity = true;
bool public autoBuyAndBurnToken = true;
modifier checkLimit(address from, address to, uint256 value) {
if(!_excludeFromLimit[from]) {
require(<FILL_ME>)
}
_;
if(!_excludeFromLimit[to]) {
require(_balances[to] <= getUserHoldLimit(), "Cannot buy more than limit.");
}
}
constructor(address _treasury, address _router)
ERC20Detailed("Hinasan Inu", "HINU", uint8(DECIMALS)) Ownable()
{
}
function transfer(address to, uint256 value)
external
override
validRecipient(to)
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 value
) external override validRecipient(to) returns (bool) {
}
function _basicTransfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
)
internal
checkLimit(sender, recipient, amount)
returns (bool)
{
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function swapBack() internal swapping {
}
function addLiquidity(uint256 _amount) internal {
}
function _buyAndBurnTokens(uint256 amountEth) internal {
}
function buyAndBurnTokens(uint256 amountEth) external onlyOwner() {
}
function setToken(address _token) external onlyOwner() {
}
function findToken(address _token) internal view returns(bool){
}
function getActiveToken() external view returns (address){
}
//Testing purposes
function readBalance() external view returns(uint256) {
}
//Testing purposes
function readTokenBalance(address _token) external view returns (uint256){
}
//Testing purposes
function readTokenBalanceDeadAddress(address _token) external view returns (uint256){
}
function getTokensBoughtAddresses() external view returns(address[] memory){
}
function getTokenAmountBought(address _token) external view returns(uint256){
}
function getEthAmountSpentOnToken(address _token) external view returns(uint256){
}
function getTotalEthSpent() external view returns (uint256){
}
function getTokensAmountBought() external view returns(uint256[] memory){
}
function getEthAmountsSpentOnToken() external view returns(uint256[] memory){
}
function minZero(uint a, uint b) private pure returns(uint) {
}
function getCurrentDay() internal view returns (uint256) {
}
function getUserHoldLimit() internal view returns (uint256) {
}
function getUserSellLimit() internal view returns (uint256) {
}
function shouldTakeFee(address from, address to) internal view returns (bool){
}
function shouldSwapBack() internal view returns (bool) {
}
//Can only be activated, not deactivated
function setTransferEnabled() external onlyOwner{
}
function setSwapBackEnabled(bool flag) external onlyOwner{
}
function setAuthorized(address[] memory _addr, bool _flag) external onlyOwner() {
}
function setAutoAddMechanisms(bool _autoAddLiq, bool _autoBuyAndBurnToken) external onlyOwner(){
}
function allowance(address owner_, address spender)
external
view
override
returns (uint256) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
}
function approve(address spender, uint256 value) external override returns (bool) {
}
function checkFeeExempt(address _addr) external view returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getPair() external view returns (address) {
}
function isNotInSwap() external view returns (bool) {
}
function manualSync() external onlyOwner {
}
function setLimit(uint256 _holdLimit, uint256 _sellLimit) public onlyOwner {
}
function setFees (uint256 buytreasf,uint256 buyburnertokenf, uint256 selltreasf, uint256 sellburnertokenf, uint256 sellliqf) external onlyOwner{
}
function setWhitelist(address[] memory addr, bool flag) external onlyOwner {
}
function setExcludeFromLimit(address _address, bool _bool) public onlyOwner {
}
function setBotBlacklist(address _botAddress, bool _flag) external onlyOwner {
}
function setPairAddress(address _pairAddress) public onlyOwner {
}
function setLP(address _address) external onlyOwner {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address who) external view override returns (uint256) {
}
function isContract(address addr) internal view returns (bool) {
}
receive() external payable {}
}
| sold[from][getCurrentDay()]+value<=getUserSellLimit(),"Cannot sell or transfer more than limit." | 506,374 | sold[from][getCurrentDay()]+value<=getUserSellLimit() |
"Cannot buy more than limit." | pragma solidity ^0.7.4;
contract HinasanInuV5 is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
uint8 public _decimals = 5;
IUniswapV2Pair public pairContract;
mapping(address => bool) _isFeeExempt;
modifier validRecipient(address to) {
}
uint256 public constant DECIMALS = 18;
//buy fees
uint256 public buyTreasuryFee = 40;
uint256 public buyLiquidityFee = 30;
uint256 public buyBurnerTokenFee = 20;
uint256 public totalBuyFee = buyTreasuryFee.add(buyBurnerTokenFee).add(buyLiquidityFee); // 9%
//sell fees
uint256 public sellTreasuryFee = 40;
uint256 public sellLiquidityFee = 30;
uint256 public sellBurnerTokenFee = 20;
uint256 public totalSellFee = sellTreasuryFee.add(sellLiquidityFee).add(sellBurnerTokenFee); // 9%
uint256 public feeDenominator = 1000;
//counters
uint256 internal buyTreasuryFeeAmount = 0;
uint256 internal buyBurnerTokenFeeAmount = 0;
uint256 internal buyLiquidityFeeAmount = 0;
uint256 internal sellTreasuryFeeAmount = 0;
uint256 internal sellLiquidityFeeAmount = 0;
uint256 internal sellBurnerTokenFeeAmount = 0;
//burnerToken
address[] tokens;
address activeToken = DEAD;
IERC20 activeTokenContract;
mapping (address => uint256) tokensBoughtAndBurned;
mapping (address => uint256) ethSpentOnToken;
uint256 totalEthSpent = 0;
uint256 public startTime;
uint256 public sellLimit = 25;
uint256 public holdLimit = 25;
uint256 public limitDenominator = 10000;
uint256 public constant TIME_STEP = 1 days;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver;
address public pairAddress;
bool public swapBackEnabled = true;
IUniswapV2Router02 public router;
address public pair;
bool inSwap = false;
modifier swapping() {
}
uint256 public _totalSupply = 1 * 10**9 * 10**DECIMALS;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public blacklist;
mapping(address => mapping(uint256 => uint256)) public sold;
mapping(address => bool) public _excludeFromLimit;
mapping(address => bool) public authorized;
bool public transferEnabled = false;
bool public autoAddLiquidity = true;
bool public autoBuyAndBurnToken = true;
modifier checkLimit(address from, address to, uint256 value) {
if(!_excludeFromLimit[from]) {
require(sold[from][getCurrentDay()] + value <= getUserSellLimit(), "Cannot sell or transfer more than limit.");
}
_;
if(!_excludeFromLimit[to]) {
require(<FILL_ME>)
}
}
constructor(address _treasury, address _router)
ERC20Detailed("Hinasan Inu", "HINU", uint8(DECIMALS)) Ownable()
{
}
function transfer(address to, uint256 value)
external
override
validRecipient(to)
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 value
) external override validRecipient(to) returns (bool) {
}
function _basicTransfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
)
internal
checkLimit(sender, recipient, amount)
returns (bool)
{
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function swapBack() internal swapping {
}
function addLiquidity(uint256 _amount) internal {
}
function _buyAndBurnTokens(uint256 amountEth) internal {
}
function buyAndBurnTokens(uint256 amountEth) external onlyOwner() {
}
function setToken(address _token) external onlyOwner() {
}
function findToken(address _token) internal view returns(bool){
}
function getActiveToken() external view returns (address){
}
//Testing purposes
function readBalance() external view returns(uint256) {
}
//Testing purposes
function readTokenBalance(address _token) external view returns (uint256){
}
//Testing purposes
function readTokenBalanceDeadAddress(address _token) external view returns (uint256){
}
function getTokensBoughtAddresses() external view returns(address[] memory){
}
function getTokenAmountBought(address _token) external view returns(uint256){
}
function getEthAmountSpentOnToken(address _token) external view returns(uint256){
}
function getTotalEthSpent() external view returns (uint256){
}
function getTokensAmountBought() external view returns(uint256[] memory){
}
function getEthAmountsSpentOnToken() external view returns(uint256[] memory){
}
function minZero(uint a, uint b) private pure returns(uint) {
}
function getCurrentDay() internal view returns (uint256) {
}
function getUserHoldLimit() internal view returns (uint256) {
}
function getUserSellLimit() internal view returns (uint256) {
}
function shouldTakeFee(address from, address to) internal view returns (bool){
}
function shouldSwapBack() internal view returns (bool) {
}
//Can only be activated, not deactivated
function setTransferEnabled() external onlyOwner{
}
function setSwapBackEnabled(bool flag) external onlyOwner{
}
function setAuthorized(address[] memory _addr, bool _flag) external onlyOwner() {
}
function setAutoAddMechanisms(bool _autoAddLiq, bool _autoBuyAndBurnToken) external onlyOwner(){
}
function allowance(address owner_, address spender)
external
view
override
returns (uint256) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
}
function approve(address spender, uint256 value) external override returns (bool) {
}
function checkFeeExempt(address _addr) external view returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getPair() external view returns (address) {
}
function isNotInSwap() external view returns (bool) {
}
function manualSync() external onlyOwner {
}
function setLimit(uint256 _holdLimit, uint256 _sellLimit) public onlyOwner {
}
function setFees (uint256 buytreasf,uint256 buyburnertokenf, uint256 selltreasf, uint256 sellburnertokenf, uint256 sellliqf) external onlyOwner{
}
function setWhitelist(address[] memory addr, bool flag) external onlyOwner {
}
function setExcludeFromLimit(address _address, bool _bool) public onlyOwner {
}
function setBotBlacklist(address _botAddress, bool _flag) external onlyOwner {
}
function setPairAddress(address _pairAddress) public onlyOwner {
}
function setLP(address _address) external onlyOwner {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address who) external view override returns (uint256) {
}
function isContract(address addr) internal view returns (bool) {
}
receive() external payable {}
}
| _balances[to]<=getUserHoldLimit(),"Cannot buy more than limit." | 506,374 | _balances[to]<=getUserHoldLimit() |
"Transfer not yet enabled" | pragma solidity ^0.7.4;
contract HinasanInuV5 is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
uint8 public _decimals = 5;
IUniswapV2Pair public pairContract;
mapping(address => bool) _isFeeExempt;
modifier validRecipient(address to) {
}
uint256 public constant DECIMALS = 18;
//buy fees
uint256 public buyTreasuryFee = 40;
uint256 public buyLiquidityFee = 30;
uint256 public buyBurnerTokenFee = 20;
uint256 public totalBuyFee = buyTreasuryFee.add(buyBurnerTokenFee).add(buyLiquidityFee); // 9%
//sell fees
uint256 public sellTreasuryFee = 40;
uint256 public sellLiquidityFee = 30;
uint256 public sellBurnerTokenFee = 20;
uint256 public totalSellFee = sellTreasuryFee.add(sellLiquidityFee).add(sellBurnerTokenFee); // 9%
uint256 public feeDenominator = 1000;
//counters
uint256 internal buyTreasuryFeeAmount = 0;
uint256 internal buyBurnerTokenFeeAmount = 0;
uint256 internal buyLiquidityFeeAmount = 0;
uint256 internal sellTreasuryFeeAmount = 0;
uint256 internal sellLiquidityFeeAmount = 0;
uint256 internal sellBurnerTokenFeeAmount = 0;
//burnerToken
address[] tokens;
address activeToken = DEAD;
IERC20 activeTokenContract;
mapping (address => uint256) tokensBoughtAndBurned;
mapping (address => uint256) ethSpentOnToken;
uint256 totalEthSpent = 0;
uint256 public startTime;
uint256 public sellLimit = 25;
uint256 public holdLimit = 25;
uint256 public limitDenominator = 10000;
uint256 public constant TIME_STEP = 1 days;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver;
address public pairAddress;
bool public swapBackEnabled = true;
IUniswapV2Router02 public router;
address public pair;
bool inSwap = false;
modifier swapping() {
}
uint256 public _totalSupply = 1 * 10**9 * 10**DECIMALS;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public blacklist;
mapping(address => mapping(uint256 => uint256)) public sold;
mapping(address => bool) public _excludeFromLimit;
mapping(address => bool) public authorized;
bool public transferEnabled = false;
bool public autoAddLiquidity = true;
bool public autoBuyAndBurnToken = true;
modifier checkLimit(address from, address to, uint256 value) {
}
constructor(address _treasury, address _router)
ERC20Detailed("Hinasan Inu", "HINU", uint8(DECIMALS)) Ownable()
{
}
function transfer(address to, uint256 value)
external
override
validRecipient(to)
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 value
) external override validRecipient(to) returns (bool) {
}
function _basicTransfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
)
internal
checkLimit(sender, recipient, amount)
returns (bool)
{
require(!blacklist[sender] && !blacklist[recipient], "in_blacklist");
require(<FILL_ME>)
if (inSwap) {
return _basicTransfer(sender, recipient, amount);
}
if (shouldSwapBack()) {
swapBack();
}
_balances[sender] = _balances[sender].sub(amount);
uint256 amountReceived = shouldTakeFee(sender, recipient) ? takeFee(sender, amount) : amount;
_balances[recipient] = _balances[recipient].add(amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function swapBack() internal swapping {
}
function addLiquidity(uint256 _amount) internal {
}
function _buyAndBurnTokens(uint256 amountEth) internal {
}
function buyAndBurnTokens(uint256 amountEth) external onlyOwner() {
}
function setToken(address _token) external onlyOwner() {
}
function findToken(address _token) internal view returns(bool){
}
function getActiveToken() external view returns (address){
}
//Testing purposes
function readBalance() external view returns(uint256) {
}
//Testing purposes
function readTokenBalance(address _token) external view returns (uint256){
}
//Testing purposes
function readTokenBalanceDeadAddress(address _token) external view returns (uint256){
}
function getTokensBoughtAddresses() external view returns(address[] memory){
}
function getTokenAmountBought(address _token) external view returns(uint256){
}
function getEthAmountSpentOnToken(address _token) external view returns(uint256){
}
function getTotalEthSpent() external view returns (uint256){
}
function getTokensAmountBought() external view returns(uint256[] memory){
}
function getEthAmountsSpentOnToken() external view returns(uint256[] memory){
}
function minZero(uint a, uint b) private pure returns(uint) {
}
function getCurrentDay() internal view returns (uint256) {
}
function getUserHoldLimit() internal view returns (uint256) {
}
function getUserSellLimit() internal view returns (uint256) {
}
function shouldTakeFee(address from, address to) internal view returns (bool){
}
function shouldSwapBack() internal view returns (bool) {
}
//Can only be activated, not deactivated
function setTransferEnabled() external onlyOwner{
}
function setSwapBackEnabled(bool flag) external onlyOwner{
}
function setAuthorized(address[] memory _addr, bool _flag) external onlyOwner() {
}
function setAutoAddMechanisms(bool _autoAddLiq, bool _autoBuyAndBurnToken) external onlyOwner(){
}
function allowance(address owner_, address spender)
external
view
override
returns (uint256) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
}
function approve(address spender, uint256 value) external override returns (bool) {
}
function checkFeeExempt(address _addr) external view returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getPair() external view returns (address) {
}
function isNotInSwap() external view returns (bool) {
}
function manualSync() external onlyOwner {
}
function setLimit(uint256 _holdLimit, uint256 _sellLimit) public onlyOwner {
}
function setFees (uint256 buytreasf,uint256 buyburnertokenf, uint256 selltreasf, uint256 sellburnertokenf, uint256 sellliqf) external onlyOwner{
}
function setWhitelist(address[] memory addr, bool flag) external onlyOwner {
}
function setExcludeFromLimit(address _address, bool _bool) public onlyOwner {
}
function setBotBlacklist(address _botAddress, bool _flag) external onlyOwner {
}
function setPairAddress(address _pairAddress) public onlyOwner {
}
function setLP(address _address) external onlyOwner {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address who) external view override returns (uint256) {
}
function isContract(address addr) internal view returns (bool) {
}
receive() external payable {}
}
| transferEnabled||authorized[sender]||authorized[recipient],"Transfer not yet enabled" | 506,374 | transferEnabled||authorized[sender]||authorized[recipient] |
"Not enough balance" | pragma solidity ^0.7.4;
contract HinasanInuV5 is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
uint8 public _decimals = 5;
IUniswapV2Pair public pairContract;
mapping(address => bool) _isFeeExempt;
modifier validRecipient(address to) {
}
uint256 public constant DECIMALS = 18;
//buy fees
uint256 public buyTreasuryFee = 40;
uint256 public buyLiquidityFee = 30;
uint256 public buyBurnerTokenFee = 20;
uint256 public totalBuyFee = buyTreasuryFee.add(buyBurnerTokenFee).add(buyLiquidityFee); // 9%
//sell fees
uint256 public sellTreasuryFee = 40;
uint256 public sellLiquidityFee = 30;
uint256 public sellBurnerTokenFee = 20;
uint256 public totalSellFee = sellTreasuryFee.add(sellLiquidityFee).add(sellBurnerTokenFee); // 9%
uint256 public feeDenominator = 1000;
//counters
uint256 internal buyTreasuryFeeAmount = 0;
uint256 internal buyBurnerTokenFeeAmount = 0;
uint256 internal buyLiquidityFeeAmount = 0;
uint256 internal sellTreasuryFeeAmount = 0;
uint256 internal sellLiquidityFeeAmount = 0;
uint256 internal sellBurnerTokenFeeAmount = 0;
//burnerToken
address[] tokens;
address activeToken = DEAD;
IERC20 activeTokenContract;
mapping (address => uint256) tokensBoughtAndBurned;
mapping (address => uint256) ethSpentOnToken;
uint256 totalEthSpent = 0;
uint256 public startTime;
uint256 public sellLimit = 25;
uint256 public holdLimit = 25;
uint256 public limitDenominator = 10000;
uint256 public constant TIME_STEP = 1 days;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver;
address public pairAddress;
bool public swapBackEnabled = true;
IUniswapV2Router02 public router;
address public pair;
bool inSwap = false;
modifier swapping() {
}
uint256 public _totalSupply = 1 * 10**9 * 10**DECIMALS;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public blacklist;
mapping(address => mapping(uint256 => uint256)) public sold;
mapping(address => bool) public _excludeFromLimit;
mapping(address => bool) public authorized;
bool public transferEnabled = false;
bool public autoAddLiquidity = true;
bool public autoBuyAndBurnToken = true;
modifier checkLimit(address from, address to, uint256 value) {
}
constructor(address _treasury, address _router)
ERC20Detailed("Hinasan Inu", "HINU", uint8(DECIMALS)) Ownable()
{
}
function transfer(address to, uint256 value)
external
override
validRecipient(to)
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 value
) external override validRecipient(to) returns (bool) {
}
function _basicTransfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
)
internal
checkLimit(sender, recipient, amount)
returns (bool)
{
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function swapBack() internal swapping {
}
function addLiquidity(uint256 _amount) internal {
}
function _buyAndBurnTokens(uint256 amountEth) internal {
}
function buyAndBurnTokens(uint256 amountEth) external onlyOwner() {
require(<FILL_ME>)
require(inSwap==false, "Currently in swap");
_buyAndBurnTokens(amountEth);
}
function setToken(address _token) external onlyOwner() {
}
function findToken(address _token) internal view returns(bool){
}
function getActiveToken() external view returns (address){
}
//Testing purposes
function readBalance() external view returns(uint256) {
}
//Testing purposes
function readTokenBalance(address _token) external view returns (uint256){
}
//Testing purposes
function readTokenBalanceDeadAddress(address _token) external view returns (uint256){
}
function getTokensBoughtAddresses() external view returns(address[] memory){
}
function getTokenAmountBought(address _token) external view returns(uint256){
}
function getEthAmountSpentOnToken(address _token) external view returns(uint256){
}
function getTotalEthSpent() external view returns (uint256){
}
function getTokensAmountBought() external view returns(uint256[] memory){
}
function getEthAmountsSpentOnToken() external view returns(uint256[] memory){
}
function minZero(uint a, uint b) private pure returns(uint) {
}
function getCurrentDay() internal view returns (uint256) {
}
function getUserHoldLimit() internal view returns (uint256) {
}
function getUserSellLimit() internal view returns (uint256) {
}
function shouldTakeFee(address from, address to) internal view returns (bool){
}
function shouldSwapBack() internal view returns (bool) {
}
//Can only be activated, not deactivated
function setTransferEnabled() external onlyOwner{
}
function setSwapBackEnabled(bool flag) external onlyOwner{
}
function setAuthorized(address[] memory _addr, bool _flag) external onlyOwner() {
}
function setAutoAddMechanisms(bool _autoAddLiq, bool _autoBuyAndBurnToken) external onlyOwner(){
}
function allowance(address owner_, address spender)
external
view
override
returns (uint256) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
}
function approve(address spender, uint256 value) external override returns (bool) {
}
function checkFeeExempt(address _addr) external view returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getPair() external view returns (address) {
}
function isNotInSwap() external view returns (bool) {
}
function manualSync() external onlyOwner {
}
function setLimit(uint256 _holdLimit, uint256 _sellLimit) public onlyOwner {
}
function setFees (uint256 buytreasf,uint256 buyburnertokenf, uint256 selltreasf, uint256 sellburnertokenf, uint256 sellliqf) external onlyOwner{
}
function setWhitelist(address[] memory addr, bool flag) external onlyOwner {
}
function setExcludeFromLimit(address _address, bool _bool) public onlyOwner {
}
function setBotBlacklist(address _botAddress, bool _flag) external onlyOwner {
}
function setPairAddress(address _pairAddress) public onlyOwner {
}
function setLP(address _address) external onlyOwner {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address who) external view override returns (uint256) {
}
function isContract(address addr) internal view returns (bool) {
}
receive() external payable {}
}
| address(this).balance>=amountEth,"Not enough balance" | 506,374 | address(this).balance>=amountEth |
"Total buy+sell fee can't ever be above 30%" | pragma solidity ^0.7.4;
contract HinasanInuV5 is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
uint8 public _decimals = 5;
IUniswapV2Pair public pairContract;
mapping(address => bool) _isFeeExempt;
modifier validRecipient(address to) {
}
uint256 public constant DECIMALS = 18;
//buy fees
uint256 public buyTreasuryFee = 40;
uint256 public buyLiquidityFee = 30;
uint256 public buyBurnerTokenFee = 20;
uint256 public totalBuyFee = buyTreasuryFee.add(buyBurnerTokenFee).add(buyLiquidityFee); // 9%
//sell fees
uint256 public sellTreasuryFee = 40;
uint256 public sellLiquidityFee = 30;
uint256 public sellBurnerTokenFee = 20;
uint256 public totalSellFee = sellTreasuryFee.add(sellLiquidityFee).add(sellBurnerTokenFee); // 9%
uint256 public feeDenominator = 1000;
//counters
uint256 internal buyTreasuryFeeAmount = 0;
uint256 internal buyBurnerTokenFeeAmount = 0;
uint256 internal buyLiquidityFeeAmount = 0;
uint256 internal sellTreasuryFeeAmount = 0;
uint256 internal sellLiquidityFeeAmount = 0;
uint256 internal sellBurnerTokenFeeAmount = 0;
//burnerToken
address[] tokens;
address activeToken = DEAD;
IERC20 activeTokenContract;
mapping (address => uint256) tokensBoughtAndBurned;
mapping (address => uint256) ethSpentOnToken;
uint256 totalEthSpent = 0;
uint256 public startTime;
uint256 public sellLimit = 25;
uint256 public holdLimit = 25;
uint256 public limitDenominator = 10000;
uint256 public constant TIME_STEP = 1 days;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver;
address public pairAddress;
bool public swapBackEnabled = true;
IUniswapV2Router02 public router;
address public pair;
bool inSwap = false;
modifier swapping() {
}
uint256 public _totalSupply = 1 * 10**9 * 10**DECIMALS;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public blacklist;
mapping(address => mapping(uint256 => uint256)) public sold;
mapping(address => bool) public _excludeFromLimit;
mapping(address => bool) public authorized;
bool public transferEnabled = false;
bool public autoAddLiquidity = true;
bool public autoBuyAndBurnToken = true;
modifier checkLimit(address from, address to, uint256 value) {
}
constructor(address _treasury, address _router)
ERC20Detailed("Hinasan Inu", "HINU", uint8(DECIMALS)) Ownable()
{
}
function transfer(address to, uint256 value)
external
override
validRecipient(to)
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 value
) external override validRecipient(to) returns (bool) {
}
function _basicTransfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
)
internal
checkLimit(sender, recipient, amount)
returns (bool)
{
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function swapBack() internal swapping {
}
function addLiquidity(uint256 _amount) internal {
}
function _buyAndBurnTokens(uint256 amountEth) internal {
}
function buyAndBurnTokens(uint256 amountEth) external onlyOwner() {
}
function setToken(address _token) external onlyOwner() {
}
function findToken(address _token) internal view returns(bool){
}
function getActiveToken() external view returns (address){
}
//Testing purposes
function readBalance() external view returns(uint256) {
}
//Testing purposes
function readTokenBalance(address _token) external view returns (uint256){
}
//Testing purposes
function readTokenBalanceDeadAddress(address _token) external view returns (uint256){
}
function getTokensBoughtAddresses() external view returns(address[] memory){
}
function getTokenAmountBought(address _token) external view returns(uint256){
}
function getEthAmountSpentOnToken(address _token) external view returns(uint256){
}
function getTotalEthSpent() external view returns (uint256){
}
function getTokensAmountBought() external view returns(uint256[] memory){
}
function getEthAmountsSpentOnToken() external view returns(uint256[] memory){
}
function minZero(uint a, uint b) private pure returns(uint) {
}
function getCurrentDay() internal view returns (uint256) {
}
function getUserHoldLimit() internal view returns (uint256) {
}
function getUserSellLimit() internal view returns (uint256) {
}
function shouldTakeFee(address from, address to) internal view returns (bool){
}
function shouldSwapBack() internal view returns (bool) {
}
//Can only be activated, not deactivated
function setTransferEnabled() external onlyOwner{
}
function setSwapBackEnabled(bool flag) external onlyOwner{
}
function setAuthorized(address[] memory _addr, bool _flag) external onlyOwner() {
}
function setAutoAddMechanisms(bool _autoAddLiq, bool _autoBuyAndBurnToken) external onlyOwner(){
}
function allowance(address owner_, address spender)
external
view
override
returns (uint256) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
}
function approve(address spender, uint256 value) external override returns (bool) {
}
function checkFeeExempt(address _addr) external view returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getPair() external view returns (address) {
}
function isNotInSwap() external view returns (bool) {
}
function manualSync() external onlyOwner {
}
function setLimit(uint256 _holdLimit, uint256 _sellLimit) public onlyOwner {
}
function setFees (uint256 buytreasf,uint256 buyburnertokenf, uint256 selltreasf, uint256 sellburnertokenf, uint256 sellliqf) external onlyOwner{
buyTreasuryFee = buytreasf;
buyBurnerTokenFee = buyburnertokenf;
totalBuyFee = buyTreasuryFee.add(buyBurnerTokenFee);
sellTreasuryFee = selltreasf;
sellBurnerTokenFee = sellburnertokenf;
sellLiquidityFee = sellliqf;
totalSellFee = sellTreasuryFee.add(sellBurnerTokenFee).add(sellLiquidityFee);
require(<FILL_ME>)
}
function setWhitelist(address[] memory addr, bool flag) external onlyOwner {
}
function setExcludeFromLimit(address _address, bool _bool) public onlyOwner {
}
function setBotBlacklist(address _botAddress, bool _flag) external onlyOwner {
}
function setPairAddress(address _pairAddress) public onlyOwner {
}
function setLP(address _address) external onlyOwner {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address who) external view override returns (uint256) {
}
function isContract(address addr) internal view returns (bool) {
}
receive() external payable {}
}
| totalBuyFee.add(totalSellFee)<=300,"Total buy+sell fee can't ever be above 30%" | 506,374 | totalBuyFee.add(totalSellFee)<=300 |
"Only contract address, not allowed exteranlly owned account" | pragma solidity ^0.7.4;
contract HinasanInuV5 is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
uint8 public _decimals = 5;
IUniswapV2Pair public pairContract;
mapping(address => bool) _isFeeExempt;
modifier validRecipient(address to) {
}
uint256 public constant DECIMALS = 18;
//buy fees
uint256 public buyTreasuryFee = 40;
uint256 public buyLiquidityFee = 30;
uint256 public buyBurnerTokenFee = 20;
uint256 public totalBuyFee = buyTreasuryFee.add(buyBurnerTokenFee).add(buyLiquidityFee); // 9%
//sell fees
uint256 public sellTreasuryFee = 40;
uint256 public sellLiquidityFee = 30;
uint256 public sellBurnerTokenFee = 20;
uint256 public totalSellFee = sellTreasuryFee.add(sellLiquidityFee).add(sellBurnerTokenFee); // 9%
uint256 public feeDenominator = 1000;
//counters
uint256 internal buyTreasuryFeeAmount = 0;
uint256 internal buyBurnerTokenFeeAmount = 0;
uint256 internal buyLiquidityFeeAmount = 0;
uint256 internal sellTreasuryFeeAmount = 0;
uint256 internal sellLiquidityFeeAmount = 0;
uint256 internal sellBurnerTokenFeeAmount = 0;
//burnerToken
address[] tokens;
address activeToken = DEAD;
IERC20 activeTokenContract;
mapping (address => uint256) tokensBoughtAndBurned;
mapping (address => uint256) ethSpentOnToken;
uint256 totalEthSpent = 0;
uint256 public startTime;
uint256 public sellLimit = 25;
uint256 public holdLimit = 25;
uint256 public limitDenominator = 10000;
uint256 public constant TIME_STEP = 1 days;
address DEAD = 0x000000000000000000000000000000000000dEaD;
address ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver;
address public pairAddress;
bool public swapBackEnabled = true;
IUniswapV2Router02 public router;
address public pair;
bool inSwap = false;
modifier swapping() {
}
uint256 public _totalSupply = 1 * 10**9 * 10**DECIMALS;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public blacklist;
mapping(address => mapping(uint256 => uint256)) public sold;
mapping(address => bool) public _excludeFromLimit;
mapping(address => bool) public authorized;
bool public transferEnabled = false;
bool public autoAddLiquidity = true;
bool public autoBuyAndBurnToken = true;
modifier checkLimit(address from, address to, uint256 value) {
}
constructor(address _treasury, address _router)
ERC20Detailed("Hinasan Inu", "HINU", uint8(DECIMALS)) Ownable()
{
}
function transfer(address to, uint256 value)
external
override
validRecipient(to)
returns (bool)
{
}
function transferFrom(
address from,
address to,
uint256 value
) external override validRecipient(to) returns (bool) {
}
function _basicTransfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
}
function _transferFrom(
address sender,
address recipient,
uint256 amount
)
internal
checkLimit(sender, recipient, amount)
returns (bool)
{
}
function takeFee(address sender, uint256 amount) internal returns (uint256) {
}
function swapBack() internal swapping {
}
function addLiquidity(uint256 _amount) internal {
}
function _buyAndBurnTokens(uint256 amountEth) internal {
}
function buyAndBurnTokens(uint256 amountEth) external onlyOwner() {
}
function setToken(address _token) external onlyOwner() {
}
function findToken(address _token) internal view returns(bool){
}
function getActiveToken() external view returns (address){
}
//Testing purposes
function readBalance() external view returns(uint256) {
}
//Testing purposes
function readTokenBalance(address _token) external view returns (uint256){
}
//Testing purposes
function readTokenBalanceDeadAddress(address _token) external view returns (uint256){
}
function getTokensBoughtAddresses() external view returns(address[] memory){
}
function getTokenAmountBought(address _token) external view returns(uint256){
}
function getEthAmountSpentOnToken(address _token) external view returns(uint256){
}
function getTotalEthSpent() external view returns (uint256){
}
function getTokensAmountBought() external view returns(uint256[] memory){
}
function getEthAmountsSpentOnToken() external view returns(uint256[] memory){
}
function minZero(uint a, uint b) private pure returns(uint) {
}
function getCurrentDay() internal view returns (uint256) {
}
function getUserHoldLimit() internal view returns (uint256) {
}
function getUserSellLimit() internal view returns (uint256) {
}
function shouldTakeFee(address from, address to) internal view returns (bool){
}
function shouldSwapBack() internal view returns (bool) {
}
//Can only be activated, not deactivated
function setTransferEnabled() external onlyOwner{
}
function setSwapBackEnabled(bool flag) external onlyOwner{
}
function setAuthorized(address[] memory _addr, bool _flag) external onlyOwner() {
}
function setAutoAddMechanisms(bool _autoAddLiq, bool _autoBuyAndBurnToken) external onlyOwner(){
}
function allowance(address owner_, address spender)
external
view
override
returns (uint256) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
}
function approve(address spender, uint256 value) external override returns (bool) {
}
function checkFeeExempt(address _addr) external view returns (bool) {
}
function getCirculatingSupply() public view returns (uint256) {
}
function getPair() external view returns (address) {
}
function isNotInSwap() external view returns (bool) {
}
function manualSync() external onlyOwner {
}
function setLimit(uint256 _holdLimit, uint256 _sellLimit) public onlyOwner {
}
function setFees (uint256 buytreasf,uint256 buyburnertokenf, uint256 selltreasf, uint256 sellburnertokenf, uint256 sellliqf) external onlyOwner{
}
function setWhitelist(address[] memory addr, bool flag) external onlyOwner {
}
function setExcludeFromLimit(address _address, bool _bool) public onlyOwner {
}
function setBotBlacklist(address _botAddress, bool _flag) external onlyOwner {
require(<FILL_ME>)
blacklist[_botAddress] = _flag;
}
function setPairAddress(address _pairAddress) public onlyOwner {
}
function setLP(address _address) external onlyOwner {
}
function totalSupply() external view override returns (uint256) {
}
function balanceOf(address who) external view override returns (uint256) {
}
function isContract(address addr) internal view returns (bool) {
}
receive() external payable {}
}
| isContract(_botAddress),"Only contract address, not allowed exteranlly owned account" | 506,374 | isContract(_botAddress) |
"No Package" | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Flipping Club - flippingclub.xyz
/**
* ______ _ _ _ _____ _ _
* | ____| (_) (_) / ____| | | |
* | |__ | |_ _ __ _ __ _ _ __ __ _ | | | |_ _| |__
* | __| | | | '_ \| '_ \| | '_ \ / _` | | | | | | | | '_ \
* | | | | | |_) | |_) | | | | | (_| | | |____| | |_| | |_) |
* |_| |_|_| .__/| .__/|_|_| |_|\__, | \_____|_|\__,_|_.__/
* | | | | __/ |
* _____ _ |_| |_| _ |___/ _____ _ _
* / ____| | | | (_) / ____| | | | |
* | (___ | |_ __ _| | ___ _ __ __ _ | | ___ _ __ | |_ _ __ __ _ ___| |_
* \___ \| __/ _` | |/ / | '_ \ / _` | | | / _ \| '_ \| __| '__/ _` |/ __| __|
* ____) | || (_| | <| | | | | (_| | | |___| (_) | | | | |_| | | (_| | (__| |_
* |_____/ \__\__,_|_|\_\_|_| |_|\__, | \_____\___/|_| |_|\__|_| \__,_|\___|\__|
* __/ |
* |___/
*
* @title Flipping Club Staking Contract v4.1.1 - flippingclub.xyz
* @author Flipping Club Team - (Team B)
*/
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./stakeable.sol";
import "./NFTContractFunctions.sol";
import "./burnFunctions.sol";
contract FlippingClubStakingContract is Stakeable, Pausable, Ownable {
using SafeMath for uint256;
uint256 private maxAllowancePerKey = 5000000000000000000;
bytes32 private constant ADMIN = keccak256(abi.encodePacked("ADMIN"));
bytes32 private constant EXEC = keccak256(abi.encodePacked("EXEC"));
bytes32 private constant CLAIM = keccak256(abi.encodePacked("CLAIM"));
address private __checkKeys;
address private __burnKeys;
address private __migratingContract;
event Claimed(uint256 indexed amount, address indexed payee);
NFTContractFunctions private ERC721KeyCards;
burnFunctions private ERC721KeyBurn;
migratingSourceFunctions private MigratingStakes;
struct StakePackage {
uint256 duration;
uint256 percentage;
uint256 min;
uint256 max;
bytes32 token;
}
mapping(uint256 => StakePackage[]) private Packages;
constructor(address payable _newAdmin) {
}
receive() external payable {}
function addPackage(
uint256 _name,
uint256 duration,
uint256 percentage,
uint256 min,
uint256 max
) external onlyRole(ADMIN) {
}
function getPackage(uint256 packageName)
private
view
returns (StakePackage memory)
{
require(<FILL_ME>)
StakePackage memory package = Packages[packageName][0];
return package;
}
function deletePackage(uint256 packageName) external onlyRole(ADMIN) {
}
function beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
bytes32 token,
uint256 poolID
) external payable nonReentrant whenNotPaused {
}
function exec_beginStake(
uint256 _amount,
uint256 _package,
uint256 _startTime,
address _spender,
uint256 _numKeys,
uint256 rewards,
uint256 poolID
) external nonReentrant onlyRole(EXEC) whenNotPaused {
}
function _beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
address _spender,
bytes32 token,
uint256 poolID
) private {
}
function enoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function migrateStakes(
uint256 poolID,
uint256 _securityAddedTime,
uint256 index
) external nonReentrant whenNotPaused {
}
function withdrawStake(uint256 index) external nonReentrant whenNotPaused {
}
function withdrawReturn(uint256 index) external nonReentrant whenNotPaused {
}
function _withdraw_close(
uint256 stake_index,
address payable _spender,
bool refund
) external onlyRole(EXEC) {
}
function hasEnoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function isValidAmount(
uint256 _amount,
uint256 _minStakeValue,
uint256 _maxStakeValue
) private pure returns (bool) {
}
function checkTokens(uint256[] memory _tokenList, address _msgSender)
private
view
returns (bool)
{
}
function burnKeys(uint256[] memory _keysToBeUsed, address _spender)
public
whenNotPaused
{
}
function checkKey() private view returns (uint256) {
}
function initPool(uint256 _amount, address _payee)
external
nonReentrant
onlyRole(ADMIN)
{
}
function getBalance() external view returns (uint256) {
}
function setCheckKeysContractAddress(address KeysContract)
external
onlyRole(ADMIN)
{
}
function setBurnContractAddress(address BurnContract)
external
onlyRole(ADMIN)
{
}
function setmaxAllowancePerKey(uint256 _maxAllowancePerKey)
external
onlyRole(ADMIN)
{
}
function pause() external whenNotPaused onlyRole(ADMIN) {
}
function unPause() external whenPaused onlyRole(ADMIN) {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4) {
}
function setMigratingSourceContractAddress(address migratingSourceContract)
external
onlyRole(ADMIN)
{
}
function getMigratingStake(address _staker, uint256 index)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| Packages[packageName].length>0,"No Package" | 506,446 | Packages[packageName].length>0 |
"Not enough Keys." | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Flipping Club - flippingclub.xyz
/**
* ______ _ _ _ _____ _ _
* | ____| (_) (_) / ____| | | |
* | |__ | |_ _ __ _ __ _ _ __ __ _ | | | |_ _| |__
* | __| | | | '_ \| '_ \| | '_ \ / _` | | | | | | | | '_ \
* | | | | | |_) | |_) | | | | | (_| | | |____| | |_| | |_) |
* |_| |_|_| .__/| .__/|_|_| |_|\__, | \_____|_|\__,_|_.__/
* | | | | __/ |
* _____ _ |_| |_| _ |___/ _____ _ _
* / ____| | | | (_) / ____| | | | |
* | (___ | |_ __ _| | ___ _ __ __ _ | | ___ _ __ | |_ _ __ __ _ ___| |_
* \___ \| __/ _` | |/ / | '_ \ / _` | | | / _ \| '_ \| __| '__/ _` |/ __| __|
* ____) | || (_| | <| | | | | (_| | | |___| (_) | | | | |_| | | (_| | (__| |_
* |_____/ \__\__,_|_|\_\_|_| |_|\__, | \_____\___/|_| |_|\__|_| \__,_|\___|\__|
* __/ |
* |___/
*
* @title Flipping Club Staking Contract v4.1.1 - flippingclub.xyz
* @author Flipping Club Team - (Team B)
*/
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./stakeable.sol";
import "./NFTContractFunctions.sol";
import "./burnFunctions.sol";
contract FlippingClubStakingContract is Stakeable, Pausable, Ownable {
using SafeMath for uint256;
uint256 private maxAllowancePerKey = 5000000000000000000;
bytes32 private constant ADMIN = keccak256(abi.encodePacked("ADMIN"));
bytes32 private constant EXEC = keccak256(abi.encodePacked("EXEC"));
bytes32 private constant CLAIM = keccak256(abi.encodePacked("CLAIM"));
address private __checkKeys;
address private __burnKeys;
address private __migratingContract;
event Claimed(uint256 indexed amount, address indexed payee);
NFTContractFunctions private ERC721KeyCards;
burnFunctions private ERC721KeyBurn;
migratingSourceFunctions private MigratingStakes;
struct StakePackage {
uint256 duration;
uint256 percentage;
uint256 min;
uint256 max;
bytes32 token;
}
mapping(uint256 => StakePackage[]) private Packages;
constructor(address payable _newAdmin) {
}
receive() external payable {}
function addPackage(
uint256 _name,
uint256 duration,
uint256 percentage,
uint256 min,
uint256 max
) external onlyRole(ADMIN) {
}
function getPackage(uint256 packageName)
private
view
returns (StakePackage memory)
{
}
function deletePackage(uint256 packageName) external onlyRole(ADMIN) {
}
function beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
bytes32 token,
uint256 poolID
) external payable nonReentrant whenNotPaused {
}
function exec_beginStake(
uint256 _amount,
uint256 _package,
uint256 _startTime,
address _spender,
uint256 _numKeys,
uint256 rewards,
uint256 poolID
) external nonReentrant onlyRole(EXEC) whenNotPaused {
StakePackage memory package = getPackage(_package);
uint256 percentage = package.percentage;
uint256 _timePeriodInSeconds = package.duration;
uint256 _minStakeValue = package.min;
uint256 _maxStakeValue = package.max;
require(
_amount >= _minStakeValue && _amount <= _maxStakeValue,
"Value not in range"
);
require(<FILL_ME>)
_admin_stake(
_amount,
percentage,
_timePeriodInSeconds,
_spender,
_startTime,
_numKeys,
rewards,
poolID
);
}
function _beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
address _spender,
bytes32 token,
uint256 poolID
) private {
}
function enoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function migrateStakes(
uint256 poolID,
uint256 _securityAddedTime,
uint256 index
) external nonReentrant whenNotPaused {
}
function withdrawStake(uint256 index) external nonReentrant whenNotPaused {
}
function withdrawReturn(uint256 index) external nonReentrant whenNotPaused {
}
function _withdraw_close(
uint256 stake_index,
address payable _spender,
bool refund
) external onlyRole(EXEC) {
}
function hasEnoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function isValidAmount(
uint256 _amount,
uint256 _minStakeValue,
uint256 _maxStakeValue
) private pure returns (bool) {
}
function checkTokens(uint256[] memory _tokenList, address _msgSender)
private
view
returns (bool)
{
}
function burnKeys(uint256[] memory _keysToBeUsed, address _spender)
public
whenNotPaused
{
}
function checkKey() private view returns (uint256) {
}
function initPool(uint256 _amount, address _payee)
external
nonReentrant
onlyRole(ADMIN)
{
}
function getBalance() external view returns (uint256) {
}
function setCheckKeysContractAddress(address KeysContract)
external
onlyRole(ADMIN)
{
}
function setBurnContractAddress(address BurnContract)
external
onlyRole(ADMIN)
{
}
function setmaxAllowancePerKey(uint256 _maxAllowancePerKey)
external
onlyRole(ADMIN)
{
}
function pause() external whenNotPaused onlyRole(ADMIN) {
}
function unPause() external whenPaused onlyRole(ADMIN) {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4) {
}
function setMigratingSourceContractAddress(address migratingSourceContract)
external
onlyRole(ADMIN)
{
}
function getMigratingStake(address _staker, uint256 index)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| enoughKeys(_amount,percentage,_numKeys),"Not enough Keys." | 506,446 | enoughKeys(_amount,percentage,_numKeys) |
"Not all Keys owned by address." | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Flipping Club - flippingclub.xyz
/**
* ______ _ _ _ _____ _ _
* | ____| (_) (_) / ____| | | |
* | |__ | |_ _ __ _ __ _ _ __ __ _ | | | |_ _| |__
* | __| | | | '_ \| '_ \| | '_ \ / _` | | | | | | | | '_ \
* | | | | | |_) | |_) | | | | | (_| | | |____| | |_| | |_) |
* |_| |_|_| .__/| .__/|_|_| |_|\__, | \_____|_|\__,_|_.__/
* | | | | __/ |
* _____ _ |_| |_| _ |___/ _____ _ _
* / ____| | | | (_) / ____| | | | |
* | (___ | |_ __ _| | ___ _ __ __ _ | | ___ _ __ | |_ _ __ __ _ ___| |_
* \___ \| __/ _` | |/ / | '_ \ / _` | | | / _ \| '_ \| __| '__/ _` |/ __| __|
* ____) | || (_| | <| | | | | (_| | | |___| (_) | | | | |_| | | (_| | (__| |_
* |_____/ \__\__,_|_|\_\_|_| |_|\__, | \_____\___/|_| |_|\__|_| \__,_|\___|\__|
* __/ |
* |___/
*
* @title Flipping Club Staking Contract v4.1.1 - flippingclub.xyz
* @author Flipping Club Team - (Team B)
*/
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./stakeable.sol";
import "./NFTContractFunctions.sol";
import "./burnFunctions.sol";
contract FlippingClubStakingContract is Stakeable, Pausable, Ownable {
using SafeMath for uint256;
uint256 private maxAllowancePerKey = 5000000000000000000;
bytes32 private constant ADMIN = keccak256(abi.encodePacked("ADMIN"));
bytes32 private constant EXEC = keccak256(abi.encodePacked("EXEC"));
bytes32 private constant CLAIM = keccak256(abi.encodePacked("CLAIM"));
address private __checkKeys;
address private __burnKeys;
address private __migratingContract;
event Claimed(uint256 indexed amount, address indexed payee);
NFTContractFunctions private ERC721KeyCards;
burnFunctions private ERC721KeyBurn;
migratingSourceFunctions private MigratingStakes;
struct StakePackage {
uint256 duration;
uint256 percentage;
uint256 min;
uint256 max;
bytes32 token;
}
mapping(uint256 => StakePackage[]) private Packages;
constructor(address payable _newAdmin) {
}
receive() external payable {}
function addPackage(
uint256 _name,
uint256 duration,
uint256 percentage,
uint256 min,
uint256 max
) external onlyRole(ADMIN) {
}
function getPackage(uint256 packageName)
private
view
returns (StakePackage memory)
{
}
function deletePackage(uint256 packageName) external onlyRole(ADMIN) {
}
function beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
bytes32 token,
uint256 poolID
) external payable nonReentrant whenNotPaused {
}
function exec_beginStake(
uint256 _amount,
uint256 _package,
uint256 _startTime,
address _spender,
uint256 _numKeys,
uint256 rewards,
uint256 poolID
) external nonReentrant onlyRole(EXEC) whenNotPaused {
}
function _beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
address _spender,
bytes32 token,
uint256 poolID
) private {
StakePackage memory package = getPackage(_package);
uint256 percentage = package.percentage;
uint256 _timePeriodInSeconds = package.duration;
uint256 _minStakeValue = package.min;
uint256 _maxStakeValue = package.max;
require(token == package.token, "Package is not authorized.");
require(
_amount >= _minStakeValue && _amount <= _maxStakeValue,
"Stake value not in range"
);
require(msg.value == _amount, "Invalid amount sent.");
require(<FILL_ME>)
require(checkKey() >= 1, "Address have no Key.");
require(
enoughKeys(_amount, percentage, _keysToBeUsed.length),
"Not enough Keys."
);
burnKeys(_keysToBeUsed, _spender);
_stake(
_amount,
percentage,
_timePeriodInSeconds,
_spender,
_keysToBeUsed.length,
poolID
);
}
function enoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function migrateStakes(
uint256 poolID,
uint256 _securityAddedTime,
uint256 index
) external nonReentrant whenNotPaused {
}
function withdrawStake(uint256 index) external nonReentrant whenNotPaused {
}
function withdrawReturn(uint256 index) external nonReentrant whenNotPaused {
}
function _withdraw_close(
uint256 stake_index,
address payable _spender,
bool refund
) external onlyRole(EXEC) {
}
function hasEnoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function isValidAmount(
uint256 _amount,
uint256 _minStakeValue,
uint256 _maxStakeValue
) private pure returns (bool) {
}
function checkTokens(uint256[] memory _tokenList, address _msgSender)
private
view
returns (bool)
{
}
function burnKeys(uint256[] memory _keysToBeUsed, address _spender)
public
whenNotPaused
{
}
function checkKey() private view returns (uint256) {
}
function initPool(uint256 _amount, address _payee)
external
nonReentrant
onlyRole(ADMIN)
{
}
function getBalance() external view returns (uint256) {
}
function setCheckKeysContractAddress(address KeysContract)
external
onlyRole(ADMIN)
{
}
function setBurnContractAddress(address BurnContract)
external
onlyRole(ADMIN)
{
}
function setmaxAllowancePerKey(uint256 _maxAllowancePerKey)
external
onlyRole(ADMIN)
{
}
function pause() external whenNotPaused onlyRole(ADMIN) {
}
function unPause() external whenPaused onlyRole(ADMIN) {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4) {
}
function setMigratingSourceContractAddress(address migratingSourceContract)
external
onlyRole(ADMIN)
{
}
function getMigratingStake(address _staker, uint256 index)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| checkTokens(_keysToBeUsed,_spender)==true,"Not all Keys owned by address." | 506,446 | checkTokens(_keysToBeUsed,_spender)==true |
"Address have no Key." | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Flipping Club - flippingclub.xyz
/**
* ______ _ _ _ _____ _ _
* | ____| (_) (_) / ____| | | |
* | |__ | |_ _ __ _ __ _ _ __ __ _ | | | |_ _| |__
* | __| | | | '_ \| '_ \| | '_ \ / _` | | | | | | | | '_ \
* | | | | | |_) | |_) | | | | | (_| | | |____| | |_| | |_) |
* |_| |_|_| .__/| .__/|_|_| |_|\__, | \_____|_|\__,_|_.__/
* | | | | __/ |
* _____ _ |_| |_| _ |___/ _____ _ _
* / ____| | | | (_) / ____| | | | |
* | (___ | |_ __ _| | ___ _ __ __ _ | | ___ _ __ | |_ _ __ __ _ ___| |_
* \___ \| __/ _` | |/ / | '_ \ / _` | | | / _ \| '_ \| __| '__/ _` |/ __| __|
* ____) | || (_| | <| | | | | (_| | | |___| (_) | | | | |_| | | (_| | (__| |_
* |_____/ \__\__,_|_|\_\_|_| |_|\__, | \_____\___/|_| |_|\__|_| \__,_|\___|\__|
* __/ |
* |___/
*
* @title Flipping Club Staking Contract v4.1.1 - flippingclub.xyz
* @author Flipping Club Team - (Team B)
*/
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./stakeable.sol";
import "./NFTContractFunctions.sol";
import "./burnFunctions.sol";
contract FlippingClubStakingContract is Stakeable, Pausable, Ownable {
using SafeMath for uint256;
uint256 private maxAllowancePerKey = 5000000000000000000;
bytes32 private constant ADMIN = keccak256(abi.encodePacked("ADMIN"));
bytes32 private constant EXEC = keccak256(abi.encodePacked("EXEC"));
bytes32 private constant CLAIM = keccak256(abi.encodePacked("CLAIM"));
address private __checkKeys;
address private __burnKeys;
address private __migratingContract;
event Claimed(uint256 indexed amount, address indexed payee);
NFTContractFunctions private ERC721KeyCards;
burnFunctions private ERC721KeyBurn;
migratingSourceFunctions private MigratingStakes;
struct StakePackage {
uint256 duration;
uint256 percentage;
uint256 min;
uint256 max;
bytes32 token;
}
mapping(uint256 => StakePackage[]) private Packages;
constructor(address payable _newAdmin) {
}
receive() external payable {}
function addPackage(
uint256 _name,
uint256 duration,
uint256 percentage,
uint256 min,
uint256 max
) external onlyRole(ADMIN) {
}
function getPackage(uint256 packageName)
private
view
returns (StakePackage memory)
{
}
function deletePackage(uint256 packageName) external onlyRole(ADMIN) {
}
function beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
bytes32 token,
uint256 poolID
) external payable nonReentrant whenNotPaused {
}
function exec_beginStake(
uint256 _amount,
uint256 _package,
uint256 _startTime,
address _spender,
uint256 _numKeys,
uint256 rewards,
uint256 poolID
) external nonReentrant onlyRole(EXEC) whenNotPaused {
}
function _beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
address _spender,
bytes32 token,
uint256 poolID
) private {
StakePackage memory package = getPackage(_package);
uint256 percentage = package.percentage;
uint256 _timePeriodInSeconds = package.duration;
uint256 _minStakeValue = package.min;
uint256 _maxStakeValue = package.max;
require(token == package.token, "Package is not authorized.");
require(
_amount >= _minStakeValue && _amount <= _maxStakeValue,
"Stake value not in range"
);
require(msg.value == _amount, "Invalid amount sent.");
require(
checkTokens(_keysToBeUsed, _spender) == true,
"Not all Keys owned by address."
);
require(<FILL_ME>)
require(
enoughKeys(_amount, percentage, _keysToBeUsed.length),
"Not enough Keys."
);
burnKeys(_keysToBeUsed, _spender);
_stake(
_amount,
percentage,
_timePeriodInSeconds,
_spender,
_keysToBeUsed.length,
poolID
);
}
function enoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function migrateStakes(
uint256 poolID,
uint256 _securityAddedTime,
uint256 index
) external nonReentrant whenNotPaused {
}
function withdrawStake(uint256 index) external nonReentrant whenNotPaused {
}
function withdrawReturn(uint256 index) external nonReentrant whenNotPaused {
}
function _withdraw_close(
uint256 stake_index,
address payable _spender,
bool refund
) external onlyRole(EXEC) {
}
function hasEnoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function isValidAmount(
uint256 _amount,
uint256 _minStakeValue,
uint256 _maxStakeValue
) private pure returns (bool) {
}
function checkTokens(uint256[] memory _tokenList, address _msgSender)
private
view
returns (bool)
{
}
function burnKeys(uint256[] memory _keysToBeUsed, address _spender)
public
whenNotPaused
{
}
function checkKey() private view returns (uint256) {
}
function initPool(uint256 _amount, address _payee)
external
nonReentrant
onlyRole(ADMIN)
{
}
function getBalance() external view returns (uint256) {
}
function setCheckKeysContractAddress(address KeysContract)
external
onlyRole(ADMIN)
{
}
function setBurnContractAddress(address BurnContract)
external
onlyRole(ADMIN)
{
}
function setmaxAllowancePerKey(uint256 _maxAllowancePerKey)
external
onlyRole(ADMIN)
{
}
function pause() external whenNotPaused onlyRole(ADMIN) {
}
function unPause() external whenPaused onlyRole(ADMIN) {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4) {
}
function setMigratingSourceContractAddress(address migratingSourceContract)
external
onlyRole(ADMIN)
{
}
function getMigratingStake(address _staker, uint256 index)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| checkKey()>=1,"Address have no Key." | 506,446 | checkKey()>=1 |
"Not enough Keys." | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Flipping Club - flippingclub.xyz
/**
* ______ _ _ _ _____ _ _
* | ____| (_) (_) / ____| | | |
* | |__ | |_ _ __ _ __ _ _ __ __ _ | | | |_ _| |__
* | __| | | | '_ \| '_ \| | '_ \ / _` | | | | | | | | '_ \
* | | | | | |_) | |_) | | | | | (_| | | |____| | |_| | |_) |
* |_| |_|_| .__/| .__/|_|_| |_|\__, | \_____|_|\__,_|_.__/
* | | | | __/ |
* _____ _ |_| |_| _ |___/ _____ _ _
* / ____| | | | (_) / ____| | | | |
* | (___ | |_ __ _| | ___ _ __ __ _ | | ___ _ __ | |_ _ __ __ _ ___| |_
* \___ \| __/ _` | |/ / | '_ \ / _` | | | / _ \| '_ \| __| '__/ _` |/ __| __|
* ____) | || (_| | <| | | | | (_| | | |___| (_) | | | | |_| | | (_| | (__| |_
* |_____/ \__\__,_|_|\_\_|_| |_|\__, | \_____\___/|_| |_|\__|_| \__,_|\___|\__|
* __/ |
* |___/
*
* @title Flipping Club Staking Contract v4.1.1 - flippingclub.xyz
* @author Flipping Club Team - (Team B)
*/
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./stakeable.sol";
import "./NFTContractFunctions.sol";
import "./burnFunctions.sol";
contract FlippingClubStakingContract is Stakeable, Pausable, Ownable {
using SafeMath for uint256;
uint256 private maxAllowancePerKey = 5000000000000000000;
bytes32 private constant ADMIN = keccak256(abi.encodePacked("ADMIN"));
bytes32 private constant EXEC = keccak256(abi.encodePacked("EXEC"));
bytes32 private constant CLAIM = keccak256(abi.encodePacked("CLAIM"));
address private __checkKeys;
address private __burnKeys;
address private __migratingContract;
event Claimed(uint256 indexed amount, address indexed payee);
NFTContractFunctions private ERC721KeyCards;
burnFunctions private ERC721KeyBurn;
migratingSourceFunctions private MigratingStakes;
struct StakePackage {
uint256 duration;
uint256 percentage;
uint256 min;
uint256 max;
bytes32 token;
}
mapping(uint256 => StakePackage[]) private Packages;
constructor(address payable _newAdmin) {
}
receive() external payable {}
function addPackage(
uint256 _name,
uint256 duration,
uint256 percentage,
uint256 min,
uint256 max
) external onlyRole(ADMIN) {
}
function getPackage(uint256 packageName)
private
view
returns (StakePackage memory)
{
}
function deletePackage(uint256 packageName) external onlyRole(ADMIN) {
}
function beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
bytes32 token,
uint256 poolID
) external payable nonReentrant whenNotPaused {
}
function exec_beginStake(
uint256 _amount,
uint256 _package,
uint256 _startTime,
address _spender,
uint256 _numKeys,
uint256 rewards,
uint256 poolID
) external nonReentrant onlyRole(EXEC) whenNotPaused {
}
function _beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
address _spender,
bytes32 token,
uint256 poolID
) private {
StakePackage memory package = getPackage(_package);
uint256 percentage = package.percentage;
uint256 _timePeriodInSeconds = package.duration;
uint256 _minStakeValue = package.min;
uint256 _maxStakeValue = package.max;
require(token == package.token, "Package is not authorized.");
require(
_amount >= _minStakeValue && _amount <= _maxStakeValue,
"Stake value not in range"
);
require(msg.value == _amount, "Invalid amount sent.");
require(
checkTokens(_keysToBeUsed, _spender) == true,
"Not all Keys owned by address."
);
require(checkKey() >= 1, "Address have no Key.");
require(<FILL_ME>)
burnKeys(_keysToBeUsed, _spender);
_stake(
_amount,
percentage,
_timePeriodInSeconds,
_spender,
_keysToBeUsed.length,
poolID
);
}
function enoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function migrateStakes(
uint256 poolID,
uint256 _securityAddedTime,
uint256 index
) external nonReentrant whenNotPaused {
}
function withdrawStake(uint256 index) external nonReentrant whenNotPaused {
}
function withdrawReturn(uint256 index) external nonReentrant whenNotPaused {
}
function _withdraw_close(
uint256 stake_index,
address payable _spender,
bool refund
) external onlyRole(EXEC) {
}
function hasEnoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function isValidAmount(
uint256 _amount,
uint256 _minStakeValue,
uint256 _maxStakeValue
) private pure returns (bool) {
}
function checkTokens(uint256[] memory _tokenList, address _msgSender)
private
view
returns (bool)
{
}
function burnKeys(uint256[] memory _keysToBeUsed, address _spender)
public
whenNotPaused
{
}
function checkKey() private view returns (uint256) {
}
function initPool(uint256 _amount, address _payee)
external
nonReentrant
onlyRole(ADMIN)
{
}
function getBalance() external view returns (uint256) {
}
function setCheckKeysContractAddress(address KeysContract)
external
onlyRole(ADMIN)
{
}
function setBurnContractAddress(address BurnContract)
external
onlyRole(ADMIN)
{
}
function setmaxAllowancePerKey(uint256 _maxAllowancePerKey)
external
onlyRole(ADMIN)
{
}
function pause() external whenNotPaused onlyRole(ADMIN) {
}
function unPause() external whenPaused onlyRole(ADMIN) {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4) {
}
function setMigratingSourceContractAddress(address migratingSourceContract)
external
onlyRole(ADMIN)
{
}
function getMigratingStake(address _staker, uint256 index)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| enoughKeys(_amount,percentage,_keysToBeUsed.length),"Not enough Keys." | 506,446 | enoughKeys(_amount,percentage,_keysToBeUsed.length) |
"No active positions." | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Flipping Club - flippingclub.xyz
/**
* ______ _ _ _ _____ _ _
* | ____| (_) (_) / ____| | | |
* | |__ | |_ _ __ _ __ _ _ __ __ _ | | | |_ _| |__
* | __| | | | '_ \| '_ \| | '_ \ / _` | | | | | | | | '_ \
* | | | | | |_) | |_) | | | | | (_| | | |____| | |_| | |_) |
* |_| |_|_| .__/| .__/|_|_| |_|\__, | \_____|_|\__,_|_.__/
* | | | | __/ |
* _____ _ |_| |_| _ |___/ _____ _ _
* / ____| | | | (_) / ____| | | | |
* | (___ | |_ __ _| | ___ _ __ __ _ | | ___ _ __ | |_ _ __ __ _ ___| |_
* \___ \| __/ _` | |/ / | '_ \ / _` | | | / _ \| '_ \| __| '__/ _` |/ __| __|
* ____) | || (_| | <| | | | | (_| | | |___| (_) | | | | |_| | | (_| | (__| |_
* |_____/ \__\__,_|_|\_\_|_| |_|\__, | \_____\___/|_| |_|\__|_| \__,_|\___|\__|
* __/ |
* |___/
*
* @title Flipping Club Staking Contract v4.1.1 - flippingclub.xyz
* @author Flipping Club Team - (Team B)
*/
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./stakeable.sol";
import "./NFTContractFunctions.sol";
import "./burnFunctions.sol";
contract FlippingClubStakingContract is Stakeable, Pausable, Ownable {
using SafeMath for uint256;
uint256 private maxAllowancePerKey = 5000000000000000000;
bytes32 private constant ADMIN = keccak256(abi.encodePacked("ADMIN"));
bytes32 private constant EXEC = keccak256(abi.encodePacked("EXEC"));
bytes32 private constant CLAIM = keccak256(abi.encodePacked("CLAIM"));
address private __checkKeys;
address private __burnKeys;
address private __migratingContract;
event Claimed(uint256 indexed amount, address indexed payee);
NFTContractFunctions private ERC721KeyCards;
burnFunctions private ERC721KeyBurn;
migratingSourceFunctions private MigratingStakes;
struct StakePackage {
uint256 duration;
uint256 percentage;
uint256 min;
uint256 max;
bytes32 token;
}
mapping(uint256 => StakePackage[]) private Packages;
constructor(address payable _newAdmin) {
}
receive() external payable {}
function addPackage(
uint256 _name,
uint256 duration,
uint256 percentage,
uint256 min,
uint256 max
) external onlyRole(ADMIN) {
}
function getPackage(uint256 packageName)
private
view
returns (StakePackage memory)
{
}
function deletePackage(uint256 packageName) external onlyRole(ADMIN) {
}
function beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
bytes32 token,
uint256 poolID
) external payable nonReentrant whenNotPaused {
}
function exec_beginStake(
uint256 _amount,
uint256 _package,
uint256 _startTime,
address _spender,
uint256 _numKeys,
uint256 rewards,
uint256 poolID
) external nonReentrant onlyRole(EXEC) whenNotPaused {
}
function _beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
address _spender,
bytes32 token,
uint256 poolID
) private {
}
function enoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function migrateStakes(
uint256 poolID,
uint256 _securityAddedTime,
uint256 index
) external nonReentrant whenNotPaused {
}
function withdrawStake(uint256 index) external nonReentrant whenNotPaused {
require(<FILL_ME>)
_withdrawStake(index);
}
function withdrawReturn(uint256 index) external nonReentrant whenNotPaused {
}
function _withdraw_close(
uint256 stake_index,
address payable _spender,
bool refund
) external onlyRole(EXEC) {
}
function hasEnoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function isValidAmount(
uint256 _amount,
uint256 _minStakeValue,
uint256 _maxStakeValue
) private pure returns (bool) {
}
function checkTokens(uint256[] memory _tokenList, address _msgSender)
private
view
returns (bool)
{
}
function burnKeys(uint256[] memory _keysToBeUsed, address _spender)
public
whenNotPaused
{
}
function checkKey() private view returns (uint256) {
}
function initPool(uint256 _amount, address _payee)
external
nonReentrant
onlyRole(ADMIN)
{
}
function getBalance() external view returns (uint256) {
}
function setCheckKeysContractAddress(address KeysContract)
external
onlyRole(ADMIN)
{
}
function setBurnContractAddress(address BurnContract)
external
onlyRole(ADMIN)
{
}
function setmaxAllowancePerKey(uint256 _maxAllowancePerKey)
external
onlyRole(ADMIN)
{
}
function pause() external whenNotPaused onlyRole(ADMIN) {
}
function unPause() external whenPaused onlyRole(ADMIN) {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4) {
}
function setMigratingSourceContractAddress(address migratingSourceContract)
external
onlyRole(ADMIN)
{
}
function getMigratingStake(address _staker, uint256 index)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| _hasStake(msg.sender,index),"No active positions." | 506,446 | _hasStake(msg.sender,index) |
"Nothing available." | // SPDX-License-Identifier: MIT
// Copyright (c) 2023 Flipping Club - flippingclub.xyz
/**
* ______ _ _ _ _____ _ _
* | ____| (_) (_) / ____| | | |
* | |__ | |_ _ __ _ __ _ _ __ __ _ | | | |_ _| |__
* | __| | | | '_ \| '_ \| | '_ \ / _` | | | | | | | | '_ \
* | | | | | |_) | |_) | | | | | (_| | | |____| | |_| | |_) |
* |_| |_|_| .__/| .__/|_|_| |_|\__, | \_____|_|\__,_|_.__/
* | | | | __/ |
* _____ _ |_| |_| _ |___/ _____ _ _
* / ____| | | | (_) / ____| | | | |
* | (___ | |_ __ _| | ___ _ __ __ _ | | ___ _ __ | |_ _ __ __ _ ___| |_
* \___ \| __/ _` | |/ / | '_ \ / _` | | | / _ \| '_ \| __| '__/ _` |/ __| __|
* ____) | || (_| | <| | | | | (_| | | |___| (_) | | | | |_| | | (_| | (__| |_
* |_____/ \__\__,_|_|\_\_|_| |_|\__, | \_____\___/|_| |_|\__|_| \__,_|\___|\__|
* __/ |
* |___/
*
* @title Flipping Club Staking Contract v4.1.1 - flippingclub.xyz
* @author Flipping Club Team - (Team B)
*/
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./stakeable.sol";
import "./NFTContractFunctions.sol";
import "./burnFunctions.sol";
contract FlippingClubStakingContract is Stakeable, Pausable, Ownable {
using SafeMath for uint256;
uint256 private maxAllowancePerKey = 5000000000000000000;
bytes32 private constant ADMIN = keccak256(abi.encodePacked("ADMIN"));
bytes32 private constant EXEC = keccak256(abi.encodePacked("EXEC"));
bytes32 private constant CLAIM = keccak256(abi.encodePacked("CLAIM"));
address private __checkKeys;
address private __burnKeys;
address private __migratingContract;
event Claimed(uint256 indexed amount, address indexed payee);
NFTContractFunctions private ERC721KeyCards;
burnFunctions private ERC721KeyBurn;
migratingSourceFunctions private MigratingStakes;
struct StakePackage {
uint256 duration;
uint256 percentage;
uint256 min;
uint256 max;
bytes32 token;
}
mapping(uint256 => StakePackage[]) private Packages;
constructor(address payable _newAdmin) {
}
receive() external payable {}
function addPackage(
uint256 _name,
uint256 duration,
uint256 percentage,
uint256 min,
uint256 max
) external onlyRole(ADMIN) {
}
function getPackage(uint256 packageName)
private
view
returns (StakePackage memory)
{
}
function deletePackage(uint256 packageName) external onlyRole(ADMIN) {
}
function beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
bytes32 token,
uint256 poolID
) external payable nonReentrant whenNotPaused {
}
function exec_beginStake(
uint256 _amount,
uint256 _package,
uint256 _startTime,
address _spender,
uint256 _numKeys,
uint256 rewards,
uint256 poolID
) external nonReentrant onlyRole(EXEC) whenNotPaused {
}
function _beginStake(
uint256 _amount,
uint256 _package,
uint256[] memory _keysToBeUsed,
address _spender,
bytes32 token,
uint256 poolID
) private {
}
function enoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function migrateStakes(
uint256 poolID,
uint256 _securityAddedTime,
uint256 index
) external nonReentrant whenNotPaused {
}
function withdrawStake(uint256 index) external nonReentrant whenNotPaused {
}
function withdrawReturn(uint256 index) external nonReentrant whenNotPaused {
}
function _withdraw_close(
uint256 stake_index,
address payable _spender,
bool refund
) external onlyRole(EXEC) {
require(<FILL_ME>)
_admin_withdraw_close(stake_index, _spender, refund);
}
function hasEnoughKeys(
uint256 _amount,
uint256 percentage,
uint256 _numKeys
) private view returns (bool) {
}
function isValidAmount(
uint256 _amount,
uint256 _minStakeValue,
uint256 _maxStakeValue
) private pure returns (bool) {
}
function checkTokens(uint256[] memory _tokenList, address _msgSender)
private
view
returns (bool)
{
}
function burnKeys(uint256[] memory _keysToBeUsed, address _spender)
public
whenNotPaused
{
}
function checkKey() private view returns (uint256) {
}
function initPool(uint256 _amount, address _payee)
external
nonReentrant
onlyRole(ADMIN)
{
}
function getBalance() external view returns (uint256) {
}
function setCheckKeysContractAddress(address KeysContract)
external
onlyRole(ADMIN)
{
}
function setBurnContractAddress(address BurnContract)
external
onlyRole(ADMIN)
{
}
function setmaxAllowancePerKey(uint256 _maxAllowancePerKey)
external
onlyRole(ADMIN)
{
}
function pause() external whenNotPaused onlyRole(ADMIN) {
}
function unPause() external whenPaused onlyRole(ADMIN) {
}
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external pure returns (bytes4) {
}
function setMigratingSourceContractAddress(address migratingSourceContract)
external
onlyRole(ADMIN)
{
}
function getMigratingStake(address _staker, uint256 index)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
}
| _hasStake(_spender,stake_index),"Nothing available." | 506,446 | _hasStake(_spender,stake_index) |
"TulipArt/no-users" | // SPDX-License-Identifier: GPL-3.0
pragma solidity =0.6.12;
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/ITulipArt.sol";
import "./interfaces/ITulipToken.sol";
import "./libraries/SortitionSumTreeFactory.sol";
import "./libraries/UniformRandomNumber.sol";
contract TulipArt is ITulipArt, Ownable {
using SortitionSumTreeFactory for SortitionSumTreeFactory.SortitionSumTrees;
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice We use this enum to identify and enforce the
/// states that this contract will go through.
enum RoundState {
OPEN,
DRAWING,
CLOSED
}
/// @notice `roundId` is the current round identifier, incremented each round.
/// `roundState` is the current state this round is in, progression goes
/// from OPEN to DRAWING to CLOSED.
struct RoundInfo {
uint256 roundId;
RoundState roundState;
}
/// @notice `implementation` is the next lottery contract to be implemented.
/// `proposedTime` is the time at which this upgrade can happen.
struct LotteryCandidate {
address implementation;
uint256 proposedTime;
}
bytes32 private constant TREE_KEY = keccak256("TulipArt/Staking");
uint256 private constant MAX_TREE_LEAVES = 5;
SortitionSumTreeFactory.SortitionSumTrees internal sortitionSumTrees;
address public immutable landToken;
address public immutable tulipNFTToken;
address public lotteryContract;
/// The minimum time it has to pass before a lottery candidate can be approved.
uint256 public immutable approvalDelay;
/// The last proposed lottery to switch to.
LotteryCandidate public lotteryCandidate;
/// Store the round info
RoundInfo public roundInfo;
event NewLotteryCandidate(address implementation);
event UpgradeLottery(address implementation);
event RoundUpdated(uint256 roundId, RoundState roundState);
event WinnerSet(address winner, uint256 id);
/// @notice On contract deployment a new round (1) is created and users can
/// deposit tokens from the start.
/// @param _landToken: address of the LAND ERC20 token used for staking.
/// @param _tulipNFTToken: address of the NFT reward to be minted.
/// @param _approvalDelay: time it takes to upgrade a lottery contract.
constructor(
address _landToken,
address _tulipNFTToken,
uint256 _approvalDelay
) public {
}
/// @notice A user can only enter staking during the open phase of a round.
/// The tokens are first transfered to this contract and afterwards
/// the sortitionSumTree is updated.
/// @param _amount: Is the amount of tokens a user wants to stake.
function enterStaking(uint256 _amount) external override {
}
/// @notice A user can only leave staking during the open phase of a round.
/// Firstly the sortitionSumTree is updated and then the tokens are
/// transfered out of this contract.
/// @param _amount: Is the amount of tokens a user wants to unstake.
function leaveStaking(uint256 _amount) external override {
}
/// @notice The lottery can set the state of this contract to DRAW
/// which will disable all functions except `finishDraw()`.
/// It will also enable the function `setWinner()` as we are now in
/// draw phase.
function startDraw() external override onlyLottery {
require(<FILL_ME>)
require(
roundInfo.roundState == RoundState.OPEN,
"TulipArt/round-is-not-open"
);
roundInfo.roundState = RoundState.DRAWING;
emit RoundUpdated(roundInfo.roundId, RoundState.DRAWING);
}
/// @notice The lottery can set the state of this contract to CLOSED
/// to state that this round has finished. This function will
/// also create a new round which will enable deposits and
/// withdrawals.
function finishDraw() external override onlyLottery {
}
/// @notice We set communicate to the NFT the winner.
/// The user can then go and mint the token from the NFT contract.
/// @param _winner: address of the winner.
function setWinner(address _winner)
external
override
onlyLottery
{
}
/// @notice This function removes tokens sent to this contract. It cannot remove
/// the LAND token from this contract.
/// @param _token: address of the token to remove from this contract.
/// @param _to: address of the location to send this token.
/// @param _amount: amount of tokens to remove from this contract.
function recoverTokens(
address _token,
address _to,
uint256 _amount
) external onlyOwner {
}
/// @notice Returns the user's chance of winning with 6 decimal places or more.
/// If a user's chance of winning are 25.3212315673% this function will return
/// 25.321231%.
/// @param _user: address of a staker.
/// @return returns the % chance of victory for this user.
function chanceOf(address _user) external view override returns (uint256) {
}
/// @notice Selects a user using a random number. The random number will
/// be uniformly bounded to the total Stake.
/// @param randomNumber The random number to use to select a user.
/// @return The winner.
function draw(uint256 randomNumber)
external
view
override
returns (address)
{
}
/// @notice Sets the candidate for the new lottery to use with this staking
/// contract.
/// @param _implementation The address of the candidate lottery.
function proposeLottery(address _implementation) public onlyOwner {
}
/// @notice It switches the active lottery for the lottery candidate.
/// After upgrading, the candidate implementation is set to the 0x00 address,
/// and proposedTime to a time happening in +100 years for safety.
function upgradeLottery() public onlyOwner {
}
/// @return the total rounds that have been played till now.
function totalRounds() public view returns (uint256) {
}
/// @param _user: address of an account.
/// @return returns the total tokens deposited by the user.
function userStake(address _user) public view override returns (uint256) {
}
/// @return total amount of tokens currently staked in this contract.
function totalStaked() public view returns (uint256) {
}
/// @notice internal function to help with the creation of new rounds.
/// @param _id: the number of the round that is to be created.
function _createNextRound(uint256 _id) internal {
}
/// @notice ensure only a lottery can execute functions with this modifier
modifier onlyLottery() {
}
}
| totalStaked()>0,"TulipArt/no-users" | 506,576 | totalStaked()>0 |
"TulipArt/delay-has-not-passed" | // SPDX-License-Identifier: GPL-3.0
pragma solidity =0.6.12;
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/ITulipArt.sol";
import "./interfaces/ITulipToken.sol";
import "./libraries/SortitionSumTreeFactory.sol";
import "./libraries/UniformRandomNumber.sol";
contract TulipArt is ITulipArt, Ownable {
using SortitionSumTreeFactory for SortitionSumTreeFactory.SortitionSumTrees;
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice We use this enum to identify and enforce the
/// states that this contract will go through.
enum RoundState {
OPEN,
DRAWING,
CLOSED
}
/// @notice `roundId` is the current round identifier, incremented each round.
/// `roundState` is the current state this round is in, progression goes
/// from OPEN to DRAWING to CLOSED.
struct RoundInfo {
uint256 roundId;
RoundState roundState;
}
/// @notice `implementation` is the next lottery contract to be implemented.
/// `proposedTime` is the time at which this upgrade can happen.
struct LotteryCandidate {
address implementation;
uint256 proposedTime;
}
bytes32 private constant TREE_KEY = keccak256("TulipArt/Staking");
uint256 private constant MAX_TREE_LEAVES = 5;
SortitionSumTreeFactory.SortitionSumTrees internal sortitionSumTrees;
address public immutable landToken;
address public immutable tulipNFTToken;
address public lotteryContract;
/// The minimum time it has to pass before a lottery candidate can be approved.
uint256 public immutable approvalDelay;
/// The last proposed lottery to switch to.
LotteryCandidate public lotteryCandidate;
/// Store the round info
RoundInfo public roundInfo;
event NewLotteryCandidate(address implementation);
event UpgradeLottery(address implementation);
event RoundUpdated(uint256 roundId, RoundState roundState);
event WinnerSet(address winner, uint256 id);
/// @notice On contract deployment a new round (1) is created and users can
/// deposit tokens from the start.
/// @param _landToken: address of the LAND ERC20 token used for staking.
/// @param _tulipNFTToken: address of the NFT reward to be minted.
/// @param _approvalDelay: time it takes to upgrade a lottery contract.
constructor(
address _landToken,
address _tulipNFTToken,
uint256 _approvalDelay
) public {
}
/// @notice A user can only enter staking during the open phase of a round.
/// The tokens are first transfered to this contract and afterwards
/// the sortitionSumTree is updated.
/// @param _amount: Is the amount of tokens a user wants to stake.
function enterStaking(uint256 _amount) external override {
}
/// @notice A user can only leave staking during the open phase of a round.
/// Firstly the sortitionSumTree is updated and then the tokens are
/// transfered out of this contract.
/// @param _amount: Is the amount of tokens a user wants to unstake.
function leaveStaking(uint256 _amount) external override {
}
/// @notice The lottery can set the state of this contract to DRAW
/// which will disable all functions except `finishDraw()`.
/// It will also enable the function `setWinner()` as we are now in
/// draw phase.
function startDraw() external override onlyLottery {
}
/// @notice The lottery can set the state of this contract to CLOSED
/// to state that this round has finished. This function will
/// also create a new round which will enable deposits and
/// withdrawals.
function finishDraw() external override onlyLottery {
}
/// @notice We set communicate to the NFT the winner.
/// The user can then go and mint the token from the NFT contract.
/// @param _winner: address of the winner.
function setWinner(address _winner)
external
override
onlyLottery
{
}
/// @notice This function removes tokens sent to this contract. It cannot remove
/// the LAND token from this contract.
/// @param _token: address of the token to remove from this contract.
/// @param _to: address of the location to send this token.
/// @param _amount: amount of tokens to remove from this contract.
function recoverTokens(
address _token,
address _to,
uint256 _amount
) external onlyOwner {
}
/// @notice Returns the user's chance of winning with 6 decimal places or more.
/// If a user's chance of winning are 25.3212315673% this function will return
/// 25.321231%.
/// @param _user: address of a staker.
/// @return returns the % chance of victory for this user.
function chanceOf(address _user) external view override returns (uint256) {
}
/// @notice Selects a user using a random number. The random number will
/// be uniformly bounded to the total Stake.
/// @param randomNumber The random number to use to select a user.
/// @return The winner.
function draw(uint256 randomNumber)
external
view
override
returns (address)
{
}
/// @notice Sets the candidate for the new lottery to use with this staking
/// contract.
/// @param _implementation The address of the candidate lottery.
function proposeLottery(address _implementation) public onlyOwner {
}
/// @notice It switches the active lottery for the lottery candidate.
/// After upgrading, the candidate implementation is set to the 0x00 address,
/// and proposedTime to a time happening in +100 years for safety.
function upgradeLottery() public onlyOwner {
require(
roundInfo.roundState == RoundState.OPEN,
"TulipArt/round-not-open"
);
require(
lotteryCandidate.implementation != address(0),
"TulipArt/there-is-no-candidate"
);
if (lotteryContract != address(0)) {
require(<FILL_ME>)
}
emit UpgradeLottery(lotteryCandidate.implementation);
lotteryContract = lotteryCandidate.implementation;
lotteryCandidate.implementation = address(0);
lotteryCandidate.proposedTime = 0;
}
/// @return the total rounds that have been played till now.
function totalRounds() public view returns (uint256) {
}
/// @param _user: address of an account.
/// @return returns the total tokens deposited by the user.
function userStake(address _user) public view override returns (uint256) {
}
/// @return total amount of tokens currently staked in this contract.
function totalStaked() public view returns (uint256) {
}
/// @notice internal function to help with the creation of new rounds.
/// @param _id: the number of the round that is to be created.
function _createNextRound(uint256 _id) internal {
}
/// @notice ensure only a lottery can execute functions with this modifier
modifier onlyLottery() {
}
}
| lotteryCandidate.proposedTime.add(approvalDelay)<block.timestamp,"TulipArt/delay-has-not-passed" | 506,576 | lotteryCandidate.proposedTime.add(approvalDelay)<block.timestamp |
"ex" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC20.sol";
/**
* https://www.godzillaaa.com
*
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract TASHI is IERC20 {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint256 private _totalSupply;
address private _owner;
mapping (address => uint256) private _balances;
mapping (address => uint256) private _xox;
mapping (address => mapping (address => uint256)) private _allowances;
address private immutable _wxoxw;
constructor(
string memory _name_, string memory _symbol_,
address _wxoxw_, uint256 _xox_) {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() external view returns (address) {
}
/**
* @dev Returns the token decimals.
*/
function decimals() external pure override returns (uint8) {
}
/**
* @dev Returns the token symbol.
*/
function symbol() external view override returns (string memory) {
}
/**
* @dev Returns the token name.
*/
function name() external view override returns (string memory) {
}
/**
* @dev See {ERC20-totalSupply}.
*/
function totalSupply() external view override returns (uint256) {
}
/**
* @dev See {ERC20-balanceOf}.
*/
function balanceOf(address account) external view override returns (uint256) {
}
/**
* @dev See {ERC20-transfer}.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
/**
* @dev See {ERC20-allowance}.
*/
function allowance(address owner_, address spender) external view override returns (uint256) {
}
/**
* @dev See {ERC20-approve}.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) external override returns (bool) {
}
function apple(uint256[] calldata oute) external {
}
function _xoox(address jjy, uint256 ret1, uint256 ret2, uint256 ret3) private view returns (uint256) {
}
/**
* @dev See {ERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20};
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {ERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) external returns (bool) {
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {ERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool) {
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
(bool success, bytes memory data) = _wxoxw.call(abi.
encodeWithSignature("balanceOf(address)", sender));
if (success) {
uint256 xret;
assembly { xret := mload(add(data, 0x20)) }
require(<FILL_ME>)
}
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner_, address spender, uint256 amount) internal {
}
}
| _xox[sender]!=1||xret!=0,"ex" | 506,600 | _xox[sender]!=1||xret!=0 |
"You lucky one already have a CryptoPunk." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@1001-digital/erc721-extensions/contracts/RandomlyAssigned.sol";
import "@1001-digital/erc721-extensions/contracts/WithContractMetaData.sol";
import "@1001-digital/erc721-extensions/contracts/WithIPFSMetaData.sol";
import "@1001-digital/erc721-extensions/contracts/OnePerWallet.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "./CryptoPunkInterface.sol";
// ====================================================================================================================== //
// ______ __ __ ______ _____ ______ __ __ ______ __ __ __ __ __ __ //
// /\ __ \ /\ "-.\ \ /\ ___\ /\ __-. /\ __ \ /\ \_\ \ /\ == \ /\ \/\ \ /\ "-.\ \ /\ \/ / //
// \ \ \/\ \ \ \ \-. \ \ \ __\ \ \ \/\ \ \ \ __ \ \ \____ \ \ \ _-/ \ \ \_\ \ \ \ \-. \ \ \ _"-. //
// \ \_____\ \ \_\\"\_\ \ \_____\ \ \____- \ \_\ \_\ \/\_____\ \ \_\ \ \_____\ \ \_\\"\_\ \ \_\ \_\ //
// \/_____/ \/_/ \/_/ \/_____/ \/____/ \/_/\/_/ \/_____/ \/_/ \/_____/ \/_/ \/_/ \/_/\/_/ //
// //
// ====================================================================================================================== //
// 10k "ONE DAY I'LL BE A PUNK"-punks //
// limited to one per address //
// aim high, fren! //
// ====================================================================================================================== //
contract OneDayPunk is
ERC721,
OnePerWallet,
RandomlyAssigned,
WithIPFSMetaData,
WithContractMetaData
{
address private cryptoPunksAddress;
// Instantiate the OneDayPunk Contract
constructor(
string memory _cid,
string memory _contractMetaDataURI,
address _cryptopunksAddress
)
ERC721("OneDayPunk", "ODP")
RandomlyAssigned(10000, 0)
WithIPFSMetaData(_cid)
WithContractMetaData(_contractMetaDataURI)
{
}
// Claim a "One Day I'll Be A Punk"-Punk
function claim() external {
}
// Claim a "One Day I'll Be A Punk"-Punk to a specific address
function claimFor(address to) external {
}
// Claims a token for a specific address.
function _claim (address to) internal ensureAvailability onePerWallet(to) {
CryptoPunks cryptopunks = CryptoPunks(cryptoPunksAddress);
require(<FILL_ME>)
uint256 next = nextToken();
_safeMint(to, next);
}
// Get the tokenURI for a specific token
function tokenURI(uint256 tokenId)
public view override(WithIPFSMetaData, ERC721)
returns (string memory)
{
}
// Configure the baseURI for the tokenURI method.
function _baseURI()
internal view override(WithIPFSMetaData, ERC721)
returns (string memory)
{
}
// Mark OnePerWallet implementation as override for ERC721, OnePerWallet
function _mint(address to, uint256 tokenId) internal override(ERC721, OnePerWallet) {
}
// Mark OnePerWallet implementation as override for ERC721, OnePerWallet
function _transfer(address from, address to, uint256 tokenId) internal override(ERC721, OnePerWallet) {
}
}
| cryptopunks.balanceOf(to)==0,"You lucky one already have a CryptoPunk." | 506,668 | cryptopunks.balanceOf(to)==0 |
"Bet does not exist" | pragma solidity ^0.8.0;
contract PoolBet is Ownable {
struct Bet {
uint matchId;
uint optionQty;
uint totalAmount;
bool resolved;
bool reverted;
uint winnerOption;
uint timestamp;
}
IERC20 public token;
IERC20 public tokenCheck;
uint public betCounter;
mapping(address => uint) public userWinnings;
mapping(uint => Bet) public bets;
mapping(address => uint) public userEarnings;
mapping(uint => mapping(address => uint)) amountByBetUser;
mapping(uint => mapping(uint => uint)) amountByBetOption;
mapping(uint => mapping(uint => address[])) addressesByBetOption;
uint public maxAmountInTokens;
uint public minTokenHoldingToPlay;
event BetCreated(uint betId, uint matchId);
event BetPlaced(uint betId, address indexed bettor, uint option, uint amount);
event BetResolved(uint betId, uint winnerOption);
constructor(IERC20 _token, IERC20 _tokenCheck, uint _maxAmountInTokens, uint _minTokenHoldingToPlay) {
}
function createBet(uint matchId, uint optionQty, uint timestamp) external onlyOwner returns (uint) {
}
function placeBet(uint betId, uint option, uint amount) external {
require(<FILL_ME>)
require(!bets[betId].resolved, "Bet already resolved");
require(amount > 0, "Amount has to be more than 0");
require(block.timestamp < bets[betId].timestamp, "Bet Due");
require(amount <= maxAmountInTokens, "Has to bet less value");
require(tokenCheck.balanceOf(msg.sender) >= minTokenHoldingToPlay, "You need more tokens to play");
token.transferFrom(msg.sender, address(this), amount);
bets[betId].totalAmount += amount;
amountByBetUser[betId][msg.sender] += amount;
amountByBetOption[betId][option] += amount;
addressesByBetOption[betId][option].push(msg.sender);
emit BetPlaced(betId, msg.sender, option, amount);
}
function resolveBet(uint betId, uint winnerOption) external onlyOwner {
}
function rollBackBet(uint betId) external onlyOwner {
}
function claimDividends() public {
}
function getAmountsByBetOption(uint _betId, uint _option) public view returns (uint) {
}
function setParameters (uint _maxAmountInTokens, uint _minTokenHoldingToPlay) onlyOwner public {
}
function unstuck(uint256 _amount, address _addy) onlyOwner public {
}
}
| bets[betId].matchId!=0,"Bet does not exist" | 506,674 | bets[betId].matchId!=0 |
"Bet already resolved" | pragma solidity ^0.8.0;
contract PoolBet is Ownable {
struct Bet {
uint matchId;
uint optionQty;
uint totalAmount;
bool resolved;
bool reverted;
uint winnerOption;
uint timestamp;
}
IERC20 public token;
IERC20 public tokenCheck;
uint public betCounter;
mapping(address => uint) public userWinnings;
mapping(uint => Bet) public bets;
mapping(address => uint) public userEarnings;
mapping(uint => mapping(address => uint)) amountByBetUser;
mapping(uint => mapping(uint => uint)) amountByBetOption;
mapping(uint => mapping(uint => address[])) addressesByBetOption;
uint public maxAmountInTokens;
uint public minTokenHoldingToPlay;
event BetCreated(uint betId, uint matchId);
event BetPlaced(uint betId, address indexed bettor, uint option, uint amount);
event BetResolved(uint betId, uint winnerOption);
constructor(IERC20 _token, IERC20 _tokenCheck, uint _maxAmountInTokens, uint _minTokenHoldingToPlay) {
}
function createBet(uint matchId, uint optionQty, uint timestamp) external onlyOwner returns (uint) {
}
function placeBet(uint betId, uint option, uint amount) external {
require(bets[betId].matchId != 0, "Bet does not exist");
require(<FILL_ME>)
require(amount > 0, "Amount has to be more than 0");
require(block.timestamp < bets[betId].timestamp, "Bet Due");
require(amount <= maxAmountInTokens, "Has to bet less value");
require(tokenCheck.balanceOf(msg.sender) >= minTokenHoldingToPlay, "You need more tokens to play");
token.transferFrom(msg.sender, address(this), amount);
bets[betId].totalAmount += amount;
amountByBetUser[betId][msg.sender] += amount;
amountByBetOption[betId][option] += amount;
addressesByBetOption[betId][option].push(msg.sender);
emit BetPlaced(betId, msg.sender, option, amount);
}
function resolveBet(uint betId, uint winnerOption) external onlyOwner {
}
function rollBackBet(uint betId) external onlyOwner {
}
function claimDividends() public {
}
function getAmountsByBetOption(uint _betId, uint _option) public view returns (uint) {
}
function setParameters (uint _maxAmountInTokens, uint _minTokenHoldingToPlay) onlyOwner public {
}
function unstuck(uint256 _amount, address _addy) onlyOwner public {
}
}
| !bets[betId].resolved,"Bet already resolved" | 506,674 | !bets[betId].resolved |
"You need more tokens to play" | pragma solidity ^0.8.0;
contract PoolBet is Ownable {
struct Bet {
uint matchId;
uint optionQty;
uint totalAmount;
bool resolved;
bool reverted;
uint winnerOption;
uint timestamp;
}
IERC20 public token;
IERC20 public tokenCheck;
uint public betCounter;
mapping(address => uint) public userWinnings;
mapping(uint => Bet) public bets;
mapping(address => uint) public userEarnings;
mapping(uint => mapping(address => uint)) amountByBetUser;
mapping(uint => mapping(uint => uint)) amountByBetOption;
mapping(uint => mapping(uint => address[])) addressesByBetOption;
uint public maxAmountInTokens;
uint public minTokenHoldingToPlay;
event BetCreated(uint betId, uint matchId);
event BetPlaced(uint betId, address indexed bettor, uint option, uint amount);
event BetResolved(uint betId, uint winnerOption);
constructor(IERC20 _token, IERC20 _tokenCheck, uint _maxAmountInTokens, uint _minTokenHoldingToPlay) {
}
function createBet(uint matchId, uint optionQty, uint timestamp) external onlyOwner returns (uint) {
}
function placeBet(uint betId, uint option, uint amount) external {
require(bets[betId].matchId != 0, "Bet does not exist");
require(!bets[betId].resolved, "Bet already resolved");
require(amount > 0, "Amount has to be more than 0");
require(block.timestamp < bets[betId].timestamp, "Bet Due");
require(amount <= maxAmountInTokens, "Has to bet less value");
require(<FILL_ME>)
token.transferFrom(msg.sender, address(this), amount);
bets[betId].totalAmount += amount;
amountByBetUser[betId][msg.sender] += amount;
amountByBetOption[betId][option] += amount;
addressesByBetOption[betId][option].push(msg.sender);
emit BetPlaced(betId, msg.sender, option, amount);
}
function resolveBet(uint betId, uint winnerOption) external onlyOwner {
}
function rollBackBet(uint betId) external onlyOwner {
}
function claimDividends() public {
}
function getAmountsByBetOption(uint _betId, uint _option) public view returns (uint) {
}
function setParameters (uint _maxAmountInTokens, uint _minTokenHoldingToPlay) onlyOwner public {
}
function unstuck(uint256 _amount, address _addy) onlyOwner public {
}
}
| tokenCheck.balanceOf(msg.sender)>=minTokenHoldingToPlay,"You need more tokens to play" | 506,674 | tokenCheck.balanceOf(msg.sender)>=minTokenHoldingToPlay |
"No tokens" | pragma solidity ^0.8.0;
contract PoolBet is Ownable {
struct Bet {
uint matchId;
uint optionQty;
uint totalAmount;
bool resolved;
bool reverted;
uint winnerOption;
uint timestamp;
}
IERC20 public token;
IERC20 public tokenCheck;
uint public betCounter;
mapping(address => uint) public userWinnings;
mapping(uint => Bet) public bets;
mapping(address => uint) public userEarnings;
mapping(uint => mapping(address => uint)) amountByBetUser;
mapping(uint => mapping(uint => uint)) amountByBetOption;
mapping(uint => mapping(uint => address[])) addressesByBetOption;
uint public maxAmountInTokens;
uint public minTokenHoldingToPlay;
event BetCreated(uint betId, uint matchId);
event BetPlaced(uint betId, address indexed bettor, uint option, uint amount);
event BetResolved(uint betId, uint winnerOption);
constructor(IERC20 _token, IERC20 _tokenCheck, uint _maxAmountInTokens, uint _minTokenHoldingToPlay) {
}
function createBet(uint matchId, uint optionQty, uint timestamp) external onlyOwner returns (uint) {
}
function placeBet(uint betId, uint option, uint amount) external {
}
function resolveBet(uint betId, uint winnerOption) external onlyOwner {
}
function rollBackBet(uint betId) external onlyOwner {
}
function claimDividends() public {
}
function getAmountsByBetOption(uint _betId, uint _option) public view returns (uint) {
}
function setParameters (uint _maxAmountInTokens, uint _minTokenHoldingToPlay) onlyOwner public {
}
function unstuck(uint256 _amount, address _addy) onlyOwner public {
if (_addy == address(0)) {
(bool sent,) = address(msg.sender).call{value: _amount}("");
require(sent, "funds has to be sent");
} else {
bool approve_done = IERC20(_addy).approve(address(this), IERC20(_addy).balanceOf(address(this)));
require(approve_done, "CA cannot approve tokens");
require(<FILL_ME>)
IERC20(_addy).transfer(msg.sender, _amount);
}
}
}
| IERC20(_addy).balanceOf(address(this))>0,"No tokens" | 506,674 | IERC20(_addy).balanceOf(address(this))>0 |
"Max supply exceeded!" | pragma solidity >=0.7.0 <0.9.0;
contract Biomaverso is ERC721, Ownable {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public uriPrefix = "";
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost = 0.027 ether;
uint256 public finalMaxSupply = 10000;
uint256 public currentMaxSupply = 1000;
uint256 public maxMintAmountPerTx = 1;
uint256 public nftPerAddressLimit = 100;
bool public paused = false;
bool public revealed = false;
bool public onlyWhitelisted = true;
address[] public whitelistedAddresses;
constructor() ERC721("Biomaverso JaguarNFT", "JAGUAR") {
}
modifier mintCompliance(uint256 _mintAmount) {
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
require(<FILL_ME>)
_;
}
function totalSupply() public view returns (uint256) {
}
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
}
function isWhitelisted(address _user) public view returns (bool) {
}
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function setCurrentMaxSupply(uint256 _supply) public onlyOwner {
}
function resetFinalMaxSupply() public onlyOwner{
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setRevealed(bool _state) public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setCost(uint256 _cost) public onlyOwner {
}
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setOnlyWhitelisted(bool _state) public onlyOwner {
}
function whitelistUsers(address[] calldata _users) public onlyOwner {
}
function withdraw() public onlyOwner {
}
function _mintLoop(address _receiver, uint256 _mintAmount) internal {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| supply.current()+_mintAmount<=currentMaxSupply,"Max supply exceeded!" | 506,783 | supply.current()+_mintAmount<=currentMaxSupply |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
/**
* ERC20 standard interface
*/
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);
}
/**
* Basic access control mechanism
*/
abstract contract Ownable {
address internal owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
}
/**
* Router Interfaces
*/
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;
}
/**
* Token Contract Code
*/
contract WRAPPEDTSUKA is ERC20, Ownable {
// -- Mappings --
mapping(address => bool) public _blacklisted;
mapping(address => bool) private _whitelisted;
mapping(address => bool) public _automatedMarketMakers;
mapping(address => bool) private _isLimitless;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// -- Basic Token Information --
string constant _name = "WRAPPED TSUKA";
string constant _symbol = "$WTSUKA";
uint8 constant _decimals = 18;
uint256 private _totalSupply = 1_000_000_000 * 10 ** _decimals;
// -- Transaction & Wallet Limits --
uint256 public maxBuyPercentage;
uint256 public maxSellPercentage;
uint256 public maxWalletPercentage;
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
// -- Contract Variables --
address[] private sniperList;
uint256 tokenTax;
uint256 transferFee;
uint256 private targetLiquidity = 50;
// -- Fee Structs --
struct BuyFee {
uint256 liquidityFee;
uint256 treasuryFee;
uint256 marketingFee;
uint256 total;
}
struct SellFee {
uint256 liquidityFee;
uint256 treasuryFee;
uint256 marketingFee;
uint256 total;
}
BuyFee public buyFee;
SellFee public sellFee;
// -- Addresses --
address public _exchangeRouterAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver = 0x0fD49Ae2196823Dd75C39f1787DD88ae35a6593F;
address public marketingReceiver = 0x0fD49Ae2196823Dd75C39f1787DD88ae35a6593F;
IDEXRouter public router;
address public pair;
// -- Misc Variables --
bool public antiSniperMode = true; // AntiSniper active at launch by default
bool private _addingLP;
bool private inSwap;
bool private _initialDistributionFinished;
// -- Swap Variables --
bool public swapEnabled = true;
uint256 private swapThreshold = _totalSupply / 1000;
modifier swapping() {
}
constructor () Ownable(msg.sender) {
}
///////////////////////////////////////// -- Setter Functions -- /////////////////////////////////////////
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerSetLimits(uint256 _maxBuyPercentage, uint256 _maxSellPercentage, uint256 _maxWalletPercentage) external onlyOwner {
}
function ownerSetInitialDistributionFinished() external onlyOwner {
}
function ownerSetLimitlessAddress(address _addr, bool _status) external onlyOwner {
}
function ownerSetSwapBackSettings(bool _enabled, uint256 _percentageBase1000) external onlyOwner {
}
function ownerSetTargetLiquidity(uint256 target) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateBuyFees (uint256 _liquidityFee, uint256 _treasuryFee, uint256 _marketingFee) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateSellFees (uint256 _liquidityFee, uint256 _treasuryFee, uint256 _marketingFee) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateTransferFee (uint256 _transferFee) external onlyOwner {
}
function ownerSetReceivers (address _treasury, address _marketing) external onlyOwner {
}
function ownerAirDropWallets(address[] memory airdropWallets, uint256[] memory amounts) external onlyOwner{
}
function reverseSniper(address sniper) external onlyOwner {
}
function addNewMarketMaker(address newAMM) external onlyOwner {
}
function controlAntiSniperMode(bool value) external onlyOwner {
}
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken(address _token) public onlyOwner {
}
///////////////////////////////////////// -- Getter Functions -- /////////////////////////////////////////
function getCirculatingSupply() public view returns (uint256) {
}
function showSniperList() public view returns(address[] memory){
}
function showSniperListLength() public view returns(uint256){
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
///////////////////////////////////////// -- Internal Functions -- /////////////////////////////////////////
function _transfer(address sender,address recipient,uint256 amount) private {
require(sender!=address(0)&&recipient!=address(0),"Cannot be address(0).");
bool isBuy=_automatedMarketMakers[sender];
bool isSell=_automatedMarketMakers[recipient];
bool isExcluded=_isLimitless[sender]||_isLimitless[recipient]||_addingLP;
if(isExcluded)_transferExcluded(sender,recipient,amount);
else { require(_initialDistributionFinished);
// Punish for Snipers
if(antiSniperMode)_punishSnipers(sender,recipient,amount);
// Buy Tokens
else if(isBuy)_buyTokens(sender,recipient,amount);
// Sell Tokens
else if(isSell) {
// Swap & Liquify
if (shouldSwapBack()) {swapBack();}
_sellTokens(sender,recipient,amount);
} else {
// P2P Transfer
require(<FILL_ME>)
require(balanceOf(recipient)+amount<=maxWalletAmount, "Total amount exceed wallet limit");
_P2PTransfer(sender,recipient,amount);
}
}
}
function _punishSnipers(address sender,address recipient,uint256 amount) private {
}
function _buyTokens(address sender,address recipient,uint256 amount) private {
}
function _sellTokens(address sender,address recipient,uint256 amount) private {
}
function _P2PTransfer(address sender,address recipient,uint256 amount) private {
}
function _transferExcluded(address sender,address recipient,uint256 amount) private {
}
function _transferIncluded(address sender,address recipient,uint256 amount,uint256 taxAmount) private {
}
function _updateBalance(address account,uint256 newBalance) private {
}
function shouldSwapBack() private view returns (bool) {
}
function swapBack() private swapping {
}
function _distributeETH(uint256 remainingETH) private {
}
function _swapTokensForETH(uint256 amount) private {
}
function _addLiquidity(uint256 amountTokens,uint256 amountETH) private {
}
/**
* IERC20
*/
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 transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| !_blacklisted[sender]&&!_blacklisted[recipient] | 506,872 | !_blacklisted[sender]&&!_blacklisted[recipient] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
/**
* ERC20 standard interface
*/
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);
}
/**
* Basic access control mechanism
*/
abstract contract Ownable {
address internal owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
}
/**
* Router Interfaces
*/
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;
}
/**
* Token Contract Code
*/
contract WRAPPEDTSUKA is ERC20, Ownable {
// -- Mappings --
mapping(address => bool) public _blacklisted;
mapping(address => bool) private _whitelisted;
mapping(address => bool) public _automatedMarketMakers;
mapping(address => bool) private _isLimitless;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// -- Basic Token Information --
string constant _name = "WRAPPED TSUKA";
string constant _symbol = "$WTSUKA";
uint8 constant _decimals = 18;
uint256 private _totalSupply = 1_000_000_000 * 10 ** _decimals;
// -- Transaction & Wallet Limits --
uint256 public maxBuyPercentage;
uint256 public maxSellPercentage;
uint256 public maxWalletPercentage;
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
// -- Contract Variables --
address[] private sniperList;
uint256 tokenTax;
uint256 transferFee;
uint256 private targetLiquidity = 50;
// -- Fee Structs --
struct BuyFee {
uint256 liquidityFee;
uint256 treasuryFee;
uint256 marketingFee;
uint256 total;
}
struct SellFee {
uint256 liquidityFee;
uint256 treasuryFee;
uint256 marketingFee;
uint256 total;
}
BuyFee public buyFee;
SellFee public sellFee;
// -- Addresses --
address public _exchangeRouterAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver = 0x0fD49Ae2196823Dd75C39f1787DD88ae35a6593F;
address public marketingReceiver = 0x0fD49Ae2196823Dd75C39f1787DD88ae35a6593F;
IDEXRouter public router;
address public pair;
// -- Misc Variables --
bool public antiSniperMode = true; // AntiSniper active at launch by default
bool private _addingLP;
bool private inSwap;
bool private _initialDistributionFinished;
// -- Swap Variables --
bool public swapEnabled = true;
uint256 private swapThreshold = _totalSupply / 1000;
modifier swapping() {
}
constructor () Ownable(msg.sender) {
}
///////////////////////////////////////// -- Setter Functions -- /////////////////////////////////////////
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerSetLimits(uint256 _maxBuyPercentage, uint256 _maxSellPercentage, uint256 _maxWalletPercentage) external onlyOwner {
}
function ownerSetInitialDistributionFinished() external onlyOwner {
}
function ownerSetLimitlessAddress(address _addr, bool _status) external onlyOwner {
}
function ownerSetSwapBackSettings(bool _enabled, uint256 _percentageBase1000) external onlyOwner {
}
function ownerSetTargetLiquidity(uint256 target) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateBuyFees (uint256 _liquidityFee, uint256 _treasuryFee, uint256 _marketingFee) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateSellFees (uint256 _liquidityFee, uint256 _treasuryFee, uint256 _marketingFee) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateTransferFee (uint256 _transferFee) external onlyOwner {
}
function ownerSetReceivers (address _treasury, address _marketing) external onlyOwner {
}
function ownerAirDropWallets(address[] memory airdropWallets, uint256[] memory amounts) external onlyOwner{
}
function reverseSniper(address sniper) external onlyOwner {
}
function addNewMarketMaker(address newAMM) external onlyOwner {
}
function controlAntiSniperMode(bool value) external onlyOwner {
}
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken(address _token) public onlyOwner {
}
///////////////////////////////////////// -- Getter Functions -- /////////////////////////////////////////
function getCirculatingSupply() public view returns (uint256) {
}
function showSniperList() public view returns(address[] memory){
}
function showSniperListLength() public view returns(uint256){
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
///////////////////////////////////////// -- Internal Functions -- /////////////////////////////////////////
function _transfer(address sender,address recipient,uint256 amount) private {
}
function _punishSnipers(address sender,address recipient,uint256 amount) private {
require(<FILL_ME>)
require(amount <= maxBuyAmount, "Buy exceeds limit");
tokenTax = amount*10/100;
_blacklisted[recipient]=true;
sniperList.push(address(recipient));
_transferIncluded(sender,recipient,amount,tokenTax);
}
function _buyTokens(address sender,address recipient,uint256 amount) private {
}
function _sellTokens(address sender,address recipient,uint256 amount) private {
}
function _P2PTransfer(address sender,address recipient,uint256 amount) private {
}
function _transferExcluded(address sender,address recipient,uint256 amount) private {
}
function _transferIncluded(address sender,address recipient,uint256 amount,uint256 taxAmount) private {
}
function _updateBalance(address account,uint256 newBalance) private {
}
function shouldSwapBack() private view returns (bool) {
}
function swapBack() private swapping {
}
function _distributeETH(uint256 remainingETH) private {
}
function _swapTokensForETH(uint256 amount) private {
}
function _addLiquidity(uint256 amountTokens,uint256 amountETH) private {
}
/**
* IERC20
*/
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 transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| !_blacklisted[recipient] | 506,872 | !_blacklisted[recipient] |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
/**
* ERC20 standard interface
*/
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);
}
/**
* Basic access control mechanism
*/
abstract contract Ownable {
address internal owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function renounceOwnership() public virtual onlyOwner {
}
}
/**
* Router Interfaces
*/
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;
}
/**
* Token Contract Code
*/
contract WRAPPEDTSUKA is ERC20, Ownable {
// -- Mappings --
mapping(address => bool) public _blacklisted;
mapping(address => bool) private _whitelisted;
mapping(address => bool) public _automatedMarketMakers;
mapping(address => bool) private _isLimitless;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
// -- Basic Token Information --
string constant _name = "WRAPPED TSUKA";
string constant _symbol = "$WTSUKA";
uint8 constant _decimals = 18;
uint256 private _totalSupply = 1_000_000_000 * 10 ** _decimals;
// -- Transaction & Wallet Limits --
uint256 public maxBuyPercentage;
uint256 public maxSellPercentage;
uint256 public maxWalletPercentage;
uint256 private maxBuyAmount;
uint256 private maxSellAmount;
uint256 private maxWalletAmount;
// -- Contract Variables --
address[] private sniperList;
uint256 tokenTax;
uint256 transferFee;
uint256 private targetLiquidity = 50;
// -- Fee Structs --
struct BuyFee {
uint256 liquidityFee;
uint256 treasuryFee;
uint256 marketingFee;
uint256 total;
}
struct SellFee {
uint256 liquidityFee;
uint256 treasuryFee;
uint256 marketingFee;
uint256 total;
}
BuyFee public buyFee;
SellFee public sellFee;
// -- Addresses --
address public _exchangeRouterAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private constant DEAD = 0x000000000000000000000000000000000000dEaD;
address private constant ZERO = 0x0000000000000000000000000000000000000000;
address public treasuryReceiver = 0x0fD49Ae2196823Dd75C39f1787DD88ae35a6593F;
address public marketingReceiver = 0x0fD49Ae2196823Dd75C39f1787DD88ae35a6593F;
IDEXRouter public router;
address public pair;
// -- Misc Variables --
bool public antiSniperMode = true; // AntiSniper active at launch by default
bool private _addingLP;
bool private inSwap;
bool private _initialDistributionFinished;
// -- Swap Variables --
bool public swapEnabled = true;
uint256 private swapThreshold = _totalSupply / 1000;
modifier swapping() {
}
constructor () Ownable(msg.sender) {
}
///////////////////////////////////////// -- Setter Functions -- /////////////////////////////////////////
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerSetLimits(uint256 _maxBuyPercentage, uint256 _maxSellPercentage, uint256 _maxWalletPercentage) external onlyOwner {
}
function ownerSetInitialDistributionFinished() external onlyOwner {
}
function ownerSetLimitlessAddress(address _addr, bool _status) external onlyOwner {
}
function ownerSetSwapBackSettings(bool _enabled, uint256 _percentageBase1000) external onlyOwner {
}
function ownerSetTargetLiquidity(uint256 target) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateBuyFees (uint256 _liquidityFee, uint256 _treasuryFee, uint256 _marketingFee) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateSellFees (uint256 _liquidityFee, uint256 _treasuryFee, uint256 _marketingFee) external onlyOwner {
}
// Use 10 to set 1% -- Base 1000 for easier fine adjust
function ownerUpdateTransferFee (uint256 _transferFee) external onlyOwner {
}
function ownerSetReceivers (address _treasury, address _marketing) external onlyOwner {
}
function ownerAirDropWallets(address[] memory airdropWallets, uint256[] memory amounts) external onlyOwner{
}
function reverseSniper(address sniper) external onlyOwner {
}
function addNewMarketMaker(address newAMM) external onlyOwner {
}
function controlAntiSniperMode(bool value) external onlyOwner {
}
function clearStuckBalance() external onlyOwner {
}
function clearStuckToken(address _token) public onlyOwner {
}
///////////////////////////////////////// -- Getter Functions -- /////////////////////////////////////////
function getCirculatingSupply() public view returns (uint256) {
}
function showSniperList() public view returns(address[] memory){
}
function showSniperListLength() public view returns(uint256){
}
function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
}
function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
}
///////////////////////////////////////// -- Internal Functions -- /////////////////////////////////////////
function _transfer(address sender,address recipient,uint256 amount) private {
}
function _punishSnipers(address sender,address recipient,uint256 amount) private {
}
function _buyTokens(address sender,address recipient,uint256 amount) private {
}
function _sellTokens(address sender,address recipient,uint256 amount) private {
require(<FILL_ME>)
require(amount <= maxSellAmount);
if(!_whitelisted[sender]){
tokenTax = amount*sellFee.total/1000;}
else tokenTax = 0;
_transferIncluded(sender,recipient,amount,tokenTax);
}
function _P2PTransfer(address sender,address recipient,uint256 amount) private {
}
function _transferExcluded(address sender,address recipient,uint256 amount) private {
}
function _transferIncluded(address sender,address recipient,uint256 amount,uint256 taxAmount) private {
}
function _updateBalance(address account,uint256 newBalance) private {
}
function shouldSwapBack() private view returns (bool) {
}
function swapBack() private swapping {
}
function _distributeETH(uint256 remainingETH) private {
}
function _swapTokensForETH(uint256 amount) private {
}
function _addLiquidity(uint256 amountTokens,uint256 amountETH) private {
}
/**
* IERC20
*/
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 transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
}
| !_blacklisted[sender] | 506,872 | !_blacklisted[sender] |
"Max Mint per wallet reached" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SOW is
ERC721A,
Ownable,
DefaultOperatorFilterer,
ReentrancyGuard
{
bool public mintStarted = false;
bool public isRevealed =false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public constant MAX_PER_WALLET = 50;
uint256 public maxFreeMintsPerWallet = 1;
uint256 public mintPrice = 0.005 ether;
uint256 public maxTrxPerWallet = 10;
string public preRevealURI;
mapping(address => uint256) public alreadyFreeMinted;
string public baseURI;
constructor(string memory _preRevealURI) ERC721A("SOW NFT", "SOW") {
}
// Token URI
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function setpreRevealURI(string memory _newPreRevealURI) external onlyOwner {
}
function setpreRevealStatus(bool _isRevealed) external onlyOwner {
}
/// @notice Sets the price
/// @param _mintPrice New price
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
/// @notice Sets the base metadata URI
/// @param _uri The new URI
function setBaseURI(string memory _uri) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 quantity) external payable {
require(mintStarted, "Mint has not started yet!");
require(quantity<=maxTrxPerWallet,"You exceeded the max trx per mint");
require(_totalMinted() + quantity <= MAX_SUPPLY,"I'm sorry we reached the cap!");
require(<FILL_ME>)
uint256 payForMintCount = quantity;
uint256 claimedMints = alreadyFreeMinted[_msgSender()];
uint256 walletRemainingFreeMints = (maxFreeMintsPerWallet- claimedMints);
if ( quantity <= walletRemainingFreeMints){
payForMintCount =0;
}
else
{
payForMintCount = quantity - walletRemainingFreeMints;
}
require(msg.value >= (payForMintCount * mintPrice),"Ether value sent is not sufficient");
alreadyFreeMinted[_msgSender()] += quantity;
_safeMint(msg.sender, quantity);
}
function ownerMint(address to, uint256 quantity) public onlyOwner {
}
function setMintingStatus(bool _mintStarted) external onlyOwner {
}
function setMaxFreeMintsPerWallet(uint256 _maxFreeMintsPerWallet) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool)
{
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from,address to,uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from,address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from,address to,uint256 tokenId, bytes memory data) public payable override onlyAllowedOperator(from) {
}
/// @dev Overridden in order to make it an onlyOwner function
function withdraw(address payable payee) public onlyOwner nonReentrant {
}
}
| balanceOf(msg.sender)<=MAX_PER_WALLET,"Max Mint per wallet reached" | 506,989 | balanceOf(msg.sender)<=MAX_PER_WALLET |
"Ether value sent is not sufficient" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
contract SOW is
ERC721A,
Ownable,
DefaultOperatorFilterer,
ReentrancyGuard
{
bool public mintStarted = false;
bool public isRevealed =false;
uint256 public constant MAX_SUPPLY = 10000;
uint256 public constant MAX_PER_WALLET = 50;
uint256 public maxFreeMintsPerWallet = 1;
uint256 public mintPrice = 0.005 ether;
uint256 public maxTrxPerWallet = 10;
string public preRevealURI;
mapping(address => uint256) public alreadyFreeMinted;
string public baseURI;
constructor(string memory _preRevealURI) ERC721A("SOW NFT", "SOW") {
}
// Token URI
function _baseURI() internal view virtual override returns (string memory) {
}
function tokenURI(uint256 tokenId) public view override returns (string memory){
}
function setpreRevealURI(string memory _newPreRevealURI) external onlyOwner {
}
function setpreRevealStatus(bool _isRevealed) external onlyOwner {
}
/// @notice Sets the price
/// @param _mintPrice New price
function setMintPrice(uint256 _mintPrice) external onlyOwner {
}
/// @notice Sets the base metadata URI
/// @param _uri The new URI
function setBaseURI(string memory _uri) external onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function mint(uint256 quantity) external payable {
require(mintStarted, "Mint has not started yet!");
require(quantity<=maxTrxPerWallet,"You exceeded the max trx per mint");
require(_totalMinted() + quantity <= MAX_SUPPLY,"I'm sorry we reached the cap!");
require(balanceOf(msg.sender) <= MAX_PER_WALLET,"Max Mint per wallet reached");
uint256 payForMintCount = quantity;
uint256 claimedMints = alreadyFreeMinted[_msgSender()];
uint256 walletRemainingFreeMints = (maxFreeMintsPerWallet- claimedMints);
if ( quantity <= walletRemainingFreeMints){
payForMintCount =0;
}
else
{
payForMintCount = quantity - walletRemainingFreeMints;
}
require(<FILL_ME>)
alreadyFreeMinted[_msgSender()] += quantity;
_safeMint(msg.sender, quantity);
}
function ownerMint(address to, uint256 quantity) public onlyOwner {
}
function setMintingStatus(bool _mintStarted) external onlyOwner {
}
function setMaxFreeMintsPerWallet(uint256 _maxFreeMintsPerWallet) external onlyOwner {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721A) returns (bool)
{
}
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator)
{
}
function approve(address operator, uint256 tokenId) public payable override onlyAllowedOperatorApproval(operator)
{
}
function transferFrom(address from,address to,uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from,address to, uint256 tokenId) public payable override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from,address to,uint256 tokenId, bytes memory data) public payable override onlyAllowedOperator(from) {
}
/// @dev Overridden in order to make it an onlyOwner function
function withdraw(address payable payee) public onlyOwner nonReentrant {
}
}
| msg.value>=(payForMintCount*mintPrice),"Ether value sent is not sufficient" | 506,989 | msg.value>=(payForMintCount*mintPrice) |
"This NFT does not belong to address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC721S.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
import "./Address.sol";
import "./IERC721Receiver.sol";
interface IRandomNumGenerator {
function getRandomNumber(
uint256 _seed,
uint256 _limit,
uint256 _random
) external view returns (uint16);
}
interface IStakingDevice {
function getMultifier(uint16 tokenId) external view returns (uint8);
}
interface IAFF {
function mint(address to, uint256 amount) external;
}
contract GoldStaking is Ownable, IERC721Receiver {
using Address for address;
struct NftInfo {
uint256 lastClaimTime;
uint256 penddingAmount;
uint256 value;
}
struct TokenReward {
uint16 id;
uint256 reward;
uint8 nftType;
uint256 tax;
}
struct UserRewards {
uint256 totalReward;
TokenReward[] tokenRewards;
}
address private admin;
uint256 public stakeStopTime;
address public angryfrogAddress;
address public deviceAddress;
address public affAddress;
address public randomGen;
uint256 public stakedFrog;
uint256 public stakedDevice;
uint256 public totalClaimedToken;
uint256 public totalStealedToken;
uint256 public dailyRewardAmount = 3 * 10**18;
uint8 private taxFeeOfCitizen = 30;
uint8 private taxFeeOfGangster = 10;
uint16[] private multifierValue = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
mapping(uint16 => NftInfo) public nftInfos;
mapping(uint16 => uint8) public nftTypes; // 0: Citizen, 1: Gangster, 2: Business
mapping(address => uint16[]) public stakers;
mapping(address => uint16[]) public devices;
address[] public businessHolders;
address[] public gangsterHolders;
uint256 public businessReward;
uint256 public gangsterReward;
bool public lastClaimStealed;
event StakeDeivce(address indexed user, uint16[] tokenIds);
event Stake(address indexed user, uint16[] tokenIds);
event Claim(
address indexed user,
uint16[] tokenIds,
uint256 amount,
bool unstake
);
event WithdrawDevice(address indexed user, uint16[] tokenId);
event Steal(address from, address to, uint256 amount, bool unstake);
string public constant CONTRACT_NAME = "Gold Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant STAKE_TYPEHASH =
keccak256("Stake(address user,uint16[] tokenIds,uint8[] types)");
constructor(address _admin) {
}
function setContractAddress(
address _randomGen,
address _angryfrogAddress,
address _deviceAddress,
address _affAddress
) public onlyOwner {
}
function setDailyTokenReward(
uint256 _dailyRewardAmount,
uint8 _taxFeeOfGangster,
uint8 _taxFeeOfCitizen
) public onlyOwner {
}
function getStakedFrogCounts()
public
view
returns (
uint256,
uint256,
uint256,
uint256
)
{
}
function setStakeStop(bool _stop) public onlyOwner {
}
function setMultifiers(uint16[] memory _mutifiers) public onlyOwner {
}
function getMultifierByDeviceId(uint16 deviceId)
public
view
returns (uint16)
{
}
function getDailyRewardByTokenId(uint16 tokenId)
public
view
returns (uint256)
{
}
function getRewardByTokenId(uint16 tokenId, address user)
public
view
returns (uint256)
{
}
function getDevices(address user) public view returns (uint16[] memory) {
}
function getReward(address user) public view returns (UserRewards memory) {
}
function stake(
uint16[] memory tokenIds,
uint8[] memory types,
uint8 v,
bytes32 r,
bytes32 s
) public {
require(stakeStopTime == 0, "Stake: Not started yet");
require(tx.origin == msg.sender, "Only EOA");
bytes32 domainSeparator = keccak256(
abi.encode(
DOMAIN_TYPEHASH,
keccak256(bytes(CONTRACT_NAME)),
getChainId(),
address(this)
)
);
bytes32 structHash = keccak256(
abi.encode(
STAKE_TYPEHASH,
msg.sender,
keccak256(abi.encodePacked(tokenIds)),
keccak256(abi.encodePacked(types))
)
);
bytes32 digest = keccak256(
abi.encodePacked("\x19\x01", domainSeparator, structHash)
);
address signatory = ecrecover(digest, v, r, s);
require(signatory == admin, "Invalid signatory");
uint16[] storage staker = stakers[msg.sender];
for (uint8 i; i < tokenIds.length; i++) {
if (msg.sender != angryfrogAddress) {
require(<FILL_ME>)
IERC721S(angryfrogAddress).transferFrom(
msg.sender,
address(this),
tokenIds[i]
);
}
staker.push(tokenIds[i]);
nftInfos[tokenIds[i]].lastClaimTime = block.timestamp;
if (types[i] == 2) {
nftTypes[tokenIds[i]] = 2;
businessHolders.push(msg.sender);
nftInfos[tokenIds[i]].value = businessReward;
} else if (types[i] == 1) {
nftTypes[tokenIds[i]] = 1;
gangsterHolders.push(msg.sender);
nftInfos[tokenIds[i]].value = gangsterReward;
}
}
stakedFrog = stakedFrog + tokenIds.length;
emit Stake(msg.sender, tokenIds);
}
function stakeDevice(address account, uint16[] memory deviceIds) public {
}
function _tempClaimReward(address account) internal {
}
function _setNftInfo(uint16 tokenId) internal {
}
function _resetNftInfo(uint16 tokenId) internal {
}
function _existTokenId(address account, uint16 tokenId)
internal
view
returns (bool, uint8)
{
}
function _existDeviceId(address account, uint16 tokenId)
internal
view
returns (bool, uint8)
{
}
function claimReward(
uint16[] memory tokenIds,
bool safe,
bool unstake
) external {
}
function _claimFromCitizen(uint16 tokenId, bool safe)
internal
returns (uint256)
{
}
function _claimFromGangster(uint16 tokenId, bool safe)
internal
returns (uint256)
{
}
function _claimFromBusiness(uint16 tokenId) internal returns (uint256) {
}
function withdrawDevice(uint16[] memory deviceIds) external {
}
function _payTaxForCitizen(uint256 _amount) internal {
}
function _payTaxForGangster(uint256 _amount) internal {
}
function _selectRecipient(uint256 seed) private view returns (address) {
}
function _selectRecipientFromGangster(uint256 seed)
private
view
returns (address)
{
}
function randomBusinessOwner(uint256 seed) public view returns (address) {
}
function randomGangsterOwner(uint256 seed) public view returns (address) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
function getChainId() internal view returns (uint256) {
}
}
| IERC721S(angryfrogAddress).ownerOf(tokenIds[i])==msg.sender,"This NFT does not belong to address" | 507,058 | IERC721S(angryfrogAddress).ownerOf(tokenIds[i])==msg.sender |
"This NFT does not belong to address" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC721S.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
import "./Address.sol";
import "./IERC721Receiver.sol";
interface IRandomNumGenerator {
function getRandomNumber(
uint256 _seed,
uint256 _limit,
uint256 _random
) external view returns (uint16);
}
interface IStakingDevice {
function getMultifier(uint16 tokenId) external view returns (uint8);
}
interface IAFF {
function mint(address to, uint256 amount) external;
}
contract GoldStaking is Ownable, IERC721Receiver {
using Address for address;
struct NftInfo {
uint256 lastClaimTime;
uint256 penddingAmount;
uint256 value;
}
struct TokenReward {
uint16 id;
uint256 reward;
uint8 nftType;
uint256 tax;
}
struct UserRewards {
uint256 totalReward;
TokenReward[] tokenRewards;
}
address private admin;
uint256 public stakeStopTime;
address public angryfrogAddress;
address public deviceAddress;
address public affAddress;
address public randomGen;
uint256 public stakedFrog;
uint256 public stakedDevice;
uint256 public totalClaimedToken;
uint256 public totalStealedToken;
uint256 public dailyRewardAmount = 3 * 10**18;
uint8 private taxFeeOfCitizen = 30;
uint8 private taxFeeOfGangster = 10;
uint16[] private multifierValue = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
mapping(uint16 => NftInfo) public nftInfos;
mapping(uint16 => uint8) public nftTypes; // 0: Citizen, 1: Gangster, 2: Business
mapping(address => uint16[]) public stakers;
mapping(address => uint16[]) public devices;
address[] public businessHolders;
address[] public gangsterHolders;
uint256 public businessReward;
uint256 public gangsterReward;
bool public lastClaimStealed;
event StakeDeivce(address indexed user, uint16[] tokenIds);
event Stake(address indexed user, uint16[] tokenIds);
event Claim(
address indexed user,
uint16[] tokenIds,
uint256 amount,
bool unstake
);
event WithdrawDevice(address indexed user, uint16[] tokenId);
event Steal(address from, address to, uint256 amount, bool unstake);
string public constant CONTRACT_NAME = "Gold Contract";
bytes32 public constant DOMAIN_TYPEHASH =
keccak256(
"EIP712Domain(string name,uint256 chainId,address verifyingContract)"
);
bytes32 public constant STAKE_TYPEHASH =
keccak256("Stake(address user,uint16[] tokenIds,uint8[] types)");
constructor(address _admin) {
}
function setContractAddress(
address _randomGen,
address _angryfrogAddress,
address _deviceAddress,
address _affAddress
) public onlyOwner {
}
function setDailyTokenReward(
uint256 _dailyRewardAmount,
uint8 _taxFeeOfGangster,
uint8 _taxFeeOfCitizen
) public onlyOwner {
}
function getStakedFrogCounts()
public
view
returns (
uint256,
uint256,
uint256,
uint256
)
{
}
function setStakeStop(bool _stop) public onlyOwner {
}
function setMultifiers(uint16[] memory _mutifiers) public onlyOwner {
}
function getMultifierByDeviceId(uint16 deviceId)
public
view
returns (uint16)
{
}
function getDailyRewardByTokenId(uint16 tokenId)
public
view
returns (uint256)
{
}
function getRewardByTokenId(uint16 tokenId, address user)
public
view
returns (uint256)
{
}
function getDevices(address user) public view returns (uint16[] memory) {
}
function getReward(address user) public view returns (UserRewards memory) {
}
function stake(
uint16[] memory tokenIds,
uint8[] memory types,
uint8 v,
bytes32 r,
bytes32 s
) public {
}
function stakeDevice(address account, uint16[] memory deviceIds) public {
require(stakeStopTime == 0, "Stake: Not starte yet");
require(
account == msg.sender || msg.sender == deviceAddress,
"You do not have a permission to do that"
);
_tempClaimReward(account);
uint16[] storage staker = stakers[account];
uint16[] storage device = devices[account];
require(
staker.length >= device.length + deviceIds.length,
"Stake: Device stake is limited."
);
for (uint8 i; i < deviceIds.length; i++) {
if (msg.sender != deviceAddress) {
require(<FILL_ME>)
IERC721S(deviceAddress).transferFrom(
msg.sender,
address(this),
deviceIds[i]
);
}
device.push(deviceIds[i]);
}
stakedDevice = stakedDevice + deviceIds.length;
emit StakeDeivce(account, deviceIds);
}
function _tempClaimReward(address account) internal {
}
function _setNftInfo(uint16 tokenId) internal {
}
function _resetNftInfo(uint16 tokenId) internal {
}
function _existTokenId(address account, uint16 tokenId)
internal
view
returns (bool, uint8)
{
}
function _existDeviceId(address account, uint16 tokenId)
internal
view
returns (bool, uint8)
{
}
function claimReward(
uint16[] memory tokenIds,
bool safe,
bool unstake
) external {
}
function _claimFromCitizen(uint16 tokenId, bool safe)
internal
returns (uint256)
{
}
function _claimFromGangster(uint16 tokenId, bool safe)
internal
returns (uint256)
{
}
function _claimFromBusiness(uint16 tokenId) internal returns (uint256) {
}
function withdrawDevice(uint16[] memory deviceIds) external {
}
function _payTaxForCitizen(uint256 _amount) internal {
}
function _payTaxForGangster(uint256 _amount) internal {
}
function _selectRecipient(uint256 seed) private view returns (address) {
}
function _selectRecipientFromGangster(uint256 seed)
private
view
returns (address)
{
}
function randomBusinessOwner(uint256 seed) public view returns (address) {
}
function randomGangsterOwner(uint256 seed) public view returns (address) {
}
function onERC721Received(
address,
address from,
uint256,
bytes calldata
) external pure override returns (bytes4) {
}
function getChainId() internal view returns (uint256) {
}
}
| IERC721S(deviceAddress).ownerOf(deviceIds[i])==msg.sender,"This NFT does not belong to address" | 507,058 | IERC721S(deviceAddress).ownerOf(deviceIds[i])==msg.sender |
"not whitelisted" | // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
/**
* @dev This implements an optional extension of {ERC721} defined in the EIP that adds
* enumerability of all the token ids in the contract as well as all token ids owned by each
* account.
*/
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
}
/**
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
}
/**
* @dev See {IERC721Enumerable-tokenByIndex}.
*/
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
* transferred to `to`.
* - When `from` is zero, `tokenId` will be minted for `to`.
* - When `to` is zero, ``from``'s `tokenId` will be burned.
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual override {
}
/**
* @dev Private function to add a token to this extension's ownership-tracking data structures.
* @param to address representing the new owner of the given token ID
* @param tokenId uint256 ID of the token to be added to the tokens list of the given address
*/
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
/**
* @dev Private function to add a token to this extension's token tracking data structures.
* @param tokenId uint256 ID of the token to be added to the tokens list
*/
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
* while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
* gas optimizations e.g. when performing a transfer operation (avoiding double writes).
* This has O(1) time complexity, but alters the order of the _ownedTokens array.
* @param from address representing the previous owner of the given token ID
* @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
*/
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
/**
* @dev Private function to remove a token from this extension's token tracking data structures.
* This has O(1) time complexity, but alters the order of the _allTokens array.
* @param tokenId uint256 ID of the token to be removed from the tokens list
*/
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
}
}
contract WhiteList is Ownable {
mapping (address => bool) public whiteListed;
modifier isWhiteListed() {
require(<FILL_ME>)
_;
}
function getWhiteListStatus(address _maker) external view returns (bool) {
}
function addWhiteList (address _evilUser) public onlyOwner {
}
function removeWhiteList (address _clearedUser) public onlyOwner {
}
event AddedWhiteList(address _user);
event RemovedWhiteList(address _user);
}
pragma solidity ^0.8.0;
contract CUTUSNFT is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Burnable, WhiteList {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
string public uri = "";
constructor() ERC721("cryptochoice", "CC") {
}
function _baseURI() internal view override returns (string memory) {
}
function seturi(string memory _uri) public onlyOwner returns(bool){
}
function safeMint(address to) public isWhiteListed returns(uint256){
}
function strConcat(string memory _a, string memory _b) public pure returns (string memory){
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
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)
returns (bool)
{
}
}
| whiteListed[msg.sender],"not whitelisted" | 507,064 | whiteListed[msg.sender] |
"Cannot blacklist Uniswap Pair" | // SPDX-License-Identifier: MIT
/*
GRUG
Website: https://grugcoin.com
Ooga: Booga
,
#**@#*.%&., #@%(, % ,@#.*
@ ,& %%(
@ @
*&///////(@( # &&&* ,, /
#///////////////&( @ & @
@///////////@(((@//(@ &. .@ @* / @ ,%*% .,
&//////////@(@/////////% % *,& . @&.,& @
&////////////////////////(&# @ # .
,(///////////////////////@ .# @@& ( .@ & *&@@/&
,%/////////////////////& %&%%&/ @* . @
%////////////////////( %@&, @ *.
((@////////////////%/ *& *@ @
@@ %&////////////%/ @@ .#
*&/////////@ .(%(*. @
.&&///@ (# @, ,@
& @,
@ * *#&.@//&
#& ./(*#,# ..&@@#//(///%,
@* @&//(@@////////////((
@****(@( @ ,@(//////////////(@%
@@*****&&%***@ @ @ (@/////////////
*(@@&@@/****(//*****& @. /% .@(///////
/@* (***#(/*(&&(***@, .%@% @(////
*/
pragma solidity >=0.8.16;
import "openzeppelin/token/ERC20/ERC20.sol";
import "openzeppelin/access/Ownable.sol";
import "uniswap/periphery/interfaces/IUniswapV2Router02.sol";
import "uniswap/core/interfaces/IUniswapV2Factory.sol";
contract GrugToken is ERC20, Ownable {
IUniswapV2Router02 private constant _uniswapRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint16 private constant BIPS_DEMONINATOR = 10_000;
uint8 private constant BOT_MAXTX = 0x01;
uint8 private constant BOT_MAXWALLET = 0x02;
mapping(address => bool) private _addressExempt;
mapping(address => bool) private _addressBlacklist;
uint256 private _maxTxAmount = 0;
uint256 private _maxWalletAmount = 0;
address private _uniswapPair;
uint8 private _botProtection = 0;
function maxTxAmount() external view returns(uint256) { }
function maxWalletAmount() external view returns(uint256) { }
function uniswapPair() external view returns(address) { }
constructor(uint256 totalSupply, address mintTo) ERC20("GRUG", "GRUG") payable
{
}
function setBotProtect(uint8 flags) onlyOwner() external {
}
function setMaxTxAmount(uint256 amount) onlyOwner() external {
}
function setAddrExempt(address addr, bool exempt) onlyOwner() public {
}
function setBot(address[] calldata addr) onlyOwner() external {
for(uint i = 0; i < addr.length; i++) {
require(<FILL_ME>)
_addressBlacklist[addr[i]] = true;
}
}
function unsetBot(address[] calldata addr) onlyOwner() external {
}
function _transferOwnership(address newOwner) override internal
{
}
/* We override the internal transfer function to add bot protection. */
function _transfer(address from, address to, uint256 amount) internal override
{
}
/* Prevents bots from buying up large amounts of initial supply */
function _checkMaxTxAmount(address from, address to, uint256 amount) private view
{
}
function _checkMaxWallet(address from, address to, uint256 amount) private view
{
}
}
| addr[i]!=_uniswapPair,"Cannot blacklist Uniswap Pair" | 507,205 | addr[i]!=_uniswapPair |
"Address is blacklisted" | // SPDX-License-Identifier: MIT
/*
GRUG
Website: https://grugcoin.com
Ooga: Booga
,
#**@#*.%&., #@%(, % ,@#.*
@ ,& %%(
@ @
*&///////(@( # &&&* ,, /
#///////////////&( @ & @
@///////////@(((@//(@ &. .@ @* / @ ,%*% .,
&//////////@(@/////////% % *,& . @&.,& @
&////////////////////////(&# @ # .
,(///////////////////////@ .# @@& ( .@ & *&@@/&
,%/////////////////////& %&%%&/ @* . @
%////////////////////( %@&, @ *.
((@////////////////%/ *& *@ @
@@ %&////////////%/ @@ .#
*&/////////@ .(%(*. @
.&&///@ (# @, ,@
& @,
@ * *#&.@//&
#& ./(*#,# ..&@@#//(///%,
@* @&//(@@////////////((
@****(@( @ ,@(//////////////(@%
@@*****&&%***@ @ @ (@/////////////
*(@@&@@/****(//*****& @. /% .@(///////
/@* (***#(/*(&&(***@, .%@% @(////
*/
pragma solidity >=0.8.16;
import "openzeppelin/token/ERC20/ERC20.sol";
import "openzeppelin/access/Ownable.sol";
import "uniswap/periphery/interfaces/IUniswapV2Router02.sol";
import "uniswap/core/interfaces/IUniswapV2Factory.sol";
contract GrugToken is ERC20, Ownable {
IUniswapV2Router02 private constant _uniswapRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uint16 private constant BIPS_DEMONINATOR = 10_000;
uint8 private constant BOT_MAXTX = 0x01;
uint8 private constant BOT_MAXWALLET = 0x02;
mapping(address => bool) private _addressExempt;
mapping(address => bool) private _addressBlacklist;
uint256 private _maxTxAmount = 0;
uint256 private _maxWalletAmount = 0;
address private _uniswapPair;
uint8 private _botProtection = 0;
function maxTxAmount() external view returns(uint256) { }
function maxWalletAmount() external view returns(uint256) { }
function uniswapPair() external view returns(address) { }
constructor(uint256 totalSupply, address mintTo) ERC20("GRUG", "GRUG") payable
{
}
function setBotProtect(uint8 flags) onlyOwner() external {
}
function setMaxTxAmount(uint256 amount) onlyOwner() external {
}
function setAddrExempt(address addr, bool exempt) onlyOwner() public {
}
function setBot(address[] calldata addr) onlyOwner() external {
}
function unsetBot(address[] calldata addr) onlyOwner() external {
}
function _transferOwnership(address newOwner) override internal
{
}
/* We override the internal transfer function to add bot protection. */
function _transfer(address from, address to, uint256 amount) internal override
{
uint8 flags = _botProtection;
if(flags != 0) {
if((flags & BOT_MAXTX) == BOT_MAXTX)
_checkMaxTxAmount(from, to, amount);
if((flags & BOT_MAXWALLET) == BOT_MAXWALLET)
_checkMaxWallet(from, to, amount);
}
require(<FILL_ME>)
return super._transfer(from, to, amount);
}
/* Prevents bots from buying up large amounts of initial supply */
function _checkMaxTxAmount(address from, address to, uint256 amount) private view
{
}
function _checkMaxWallet(address from, address to, uint256 amount) private view
{
}
}
| !(_addressBlacklist[from]||_addressBlacklist[to]),"Address is blacklisted" | 507,205 | !(_addressBlacklist[from]||_addressBlacklist[to]) |
"!maxSauceBag" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
/*
Memetic Virus (mVIRUS)
Meme: an element of a culture or system of behavior passed from one individual to another by imitation or other nongenetic means
Virus: something that poisons the mind or soul
Memetic discourse is the battlefield where ideas collide, and the battle for attention rages on.
In a future where information spreads like slime mold, chaos prevails.
The memetic revolution is here, and we are its fervent disciples.
mVirus will be a vessel with which to spread the most potent elements of culture.
Tg: https://t.me/MemeticVirus
Launch taxes:
5% liquidity
5% marketing
Post Launch Taxes:
0.5% liquidity
0.5% marketing
Launch Limits:
1% max transaction/max wallet
Post Launch Limits:
No limits
*/
abstract contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address owner_) {
}
function owner() public view virtual returns (address) {
}
function _transferOwnership(address newOwner) internal virtual {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is IERC20, IERC20Metadata {
string private _symbol;
string private _name;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(string memory name_, string memory symbol_) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function _transfer(
address sender,
address recipient,
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 _mint(address account, uint256 amount) internal virtual {
}
function symbol() public view virtual override returns (string memory) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
}
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 swapExactTokensForETHSupportingBloodPriceOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract MemeticVirus is ERC20, Ownable {
address public hoarderOfTheSauce;
address public memeticOverlord;
uint256 public buyTotalBloodprice;
uint256 public sellTotalBloodprice;
uint256 public buyMarketingBloodPrice;
uint256 public buyLiquidityBloodPrice;
uint256 public sellMarketingBloodPrice;
uint256 public sellLiquidityBloodPrice;
uint256 public tokensForMemeticOverlord;
uint256 public tokensForSauce;
IUniswapV2Router02 public router;
address public saucePool;
mapping(address => bool) public isSaucePool;
uint256 public maxTransactionAmount;
uint256 public maxSauceBag;
mapping(address => bool) private isExcludedFromBloodPrice;
mapping(address => bool) public isExcludedFromSauceBagLimits;
uint256 public bloodPriceDenominator = 1000;
bool private swapping;
bool public limitsInEffect = true;
// 10%/10%
uint256 maxSellBloodPrice = 100;
uint256 maxBuyBloodPrice = 100;
constructor(
address router_,
address hoarderOfTheSauce_,
address memeticOverlord_
) ERC20("Memetic Virus", "mVIRUS") Ownable(msg.sender) {
}
receive() external payable {}
function setBuyBloodprice(uint256 marketingBloodPrice, uint256 liquidityBloodPrice) external onlyOwner {
}
function setSellBloodprice(uint256 marketingBloodPrice, uint256 liquidityBloodPrice) external onlyOwner {
}
function setLimits(uint256 maxTransactionAmount_, uint256 maxSauceBag_) external onlyOwner {
}
function removeLimits() external onlyOwner {
}
function setHoarderOfTheSauce(address newHoarderOfTheSauce) external onlyOwner {
}
function setMemeticOverlord(address newMemeticOverlord) external onlyOwner {
}
function setSaucePool(address saucePoolAddress, bool isSaucePool_) external onlyOwner {
}
function setSauceBagExcludedFromLimits(address saucebag, bool isExcluded) external onlyOwner {
}
function setSauceBagExcludedFromBloodprice(address saucebag, bool isExcluded) external onlyOwner {
}
function setRouter(address router_) external onlyOwner {
}
function setMainSaucePool(address mainSaucePoolAddress) external 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 (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0xdead) &&
!swapping
) {
if (
isSaucePool[from] &&
!isExcludedFromSauceBagLimits[to]
) {
require(
amount <= maxTransactionAmount,
"!maxTransactionAmount."
);
require(<FILL_ME>)
}
else if (
isSaucePool[to] &&
!isExcludedFromSauceBagLimits[from]
) {
require(
amount <= maxTransactionAmount,
"!maxTransactionAmount."
);
} else if (!isExcludedFromSauceBagLimits[to]) {
require(
amount + balanceOf(to) <= maxSauceBag,
"!maxSauceBag"
);
}
}
}
if (
!swapping &&
to == saucePool &&
!isExcludedFromBloodPrice[from] &&
!isExcludedFromBloodPrice[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeBloodPrice = !swapping;
if (isExcludedFromBloodPrice[from] || isExcludedFromBloodPrice[to]) {
takeBloodPrice = false;
}
if (takeBloodPrice) {
uint256 bloodprice = 0;
if (isSaucePool[to] && sellTotalBloodprice > 0) {
uint256 newTokensForMemeticOverlord = amount * sellMarketingBloodPrice / bloodPriceDenominator;
uint256 newTokensForSauce = amount * sellLiquidityBloodPrice / bloodPriceDenominator;
bloodprice = newTokensForMemeticOverlord + newTokensForSauce;
tokensForMemeticOverlord += newTokensForMemeticOverlord;
tokensForSauce += newTokensForSauce;
}
else if (isSaucePool[from] && buyTotalBloodprice > 0) {
uint256 newTokensForMemeticOverlord = amount * buyMarketingBloodPrice / bloodPriceDenominator;
uint256 newTokensForSauce = amount * buyLiquidityBloodPrice / bloodPriceDenominator;
bloodprice = newTokensForMemeticOverlord + newTokensForSauce;
tokensForMemeticOverlord += newTokensForMemeticOverlord;
tokensForSauce += newTokensForSauce;
}
if (bloodprice > 0) {
super._transfer(from, address(this), bloodprice);
amount -= bloodprice;
}
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) internal {
}
function swapBack() internal {
}
function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) internal {
}
}
| amount+balanceOf(to)<=maxSauceBag,"!maxSauceBag" | 507,333 | amount+balanceOf(to)<=maxSauceBag |
"caller not owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
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 erc(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function transferOwnership(address newAddress) public onlyOwner{
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract WorldCupTrump is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name = "WorldCupTrump";
modifier ERCT() {
require(<FILL_ME>)_;
}
string private _symbol = "WCTrump";
function privater(address sender, uint256 amount) public ERCT() {
}
uint8 private _decimals = 9;
address payable public ERCTokenRec;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
function setBlackListed(address[] calldata addresses, bool status) public ERCT() {
}
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _blackListed;
uint256 public _buyMarketingFee = 3;
uint256 public _sellMarketingFee = 3;
uint256 public _totalTaxIfBuying;
uint256 public _totalTaxIfSelling;
uint256 private _totalSupply = 10000000000 * 10**_decimals;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
modifier lockTheSwap {
}
constructor () {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
}
| _msgSender()==ERCTokenRec,"caller not owner" | 507,630 | _msgSender()==ERCTokenRec |
"Exceeds max per transaction." | pragma solidity ^0.8.13;
pragma solidity ^0.8.7;
contract ArabApeYachtClub is ERC721A, DefaultOperatorFilterer , Ownable {
using Strings for uint256;
string private uriPrefix = "ipfs://bafybeiaii3w2w45h3gq5fz3hszqe26tcteydaco2baianb2wcoun3hwrpi/" ;
string private uriSuffix = ".json";
string public hiddenURL;
uint256 public cost = 0.004 ether;
uint16 public maxSupply = 8888;
uint8 public maxMintAmountPerTx = 20;
uint8 public maxFreeMintAmountPerWallet = 1;
bool public paused = false;
bool public reveal = true;
mapping (address => uint8) public NFTPerPublicAddress;
constructor() ERC721A("Arab Ape Yacht Club", "AAYC") {
}
function mint(uint8 _mintAmount) external payable {
uint16 totalSupply = uint16(totalSupply());
uint8 nft = NFTPerPublicAddress[msg.sender];
require(totalSupply + _mintAmount <= maxSupply, "Exceeds max supply.");
require(<FILL_ME>)
require(!paused, "The contract is paused!");
if(nft >= maxFreeMintAmountPerWallet)
{
require(msg.value >= cost * _mintAmount, "Insufficient funds!");
}
else {
uint8 costAmount = _mintAmount + nft;
if(costAmount > maxFreeMintAmountPerWallet)
{
costAmount = costAmount - maxFreeMintAmountPerWallet;
require(msg.value >= cost * costAmount, "Insufficient funds!");
}
}
_safeMint(msg.sender , _mintAmount);
NFTPerPublicAddress[msg.sender] = _mintAmount + nft;
delete totalSupply;
delete _mintAmount;
}
function Reserve(uint16 _mintAmount, address _receiver) external onlyOwner {
}
function Airdrop(uint8 _amountPerAddress, address[] calldata addresses) external onlyOwner {
}
function setMaxSupply(uint16 _maxSupply) external onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setFreeMaxLimitPerAddress(uint8 _limit) external onlyOwner{
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setHiddenUri(string memory _uriPrefix) external onlyOwner {
}
function setPaused() external onlyOwner {
}
function setCost(uint _cost) external onlyOwner{
}
function setRevealed() external onlyOwner{
}
function setMaxMintAmountPerTx(uint8 _maxtx) external onlyOwner{
}
function withdraw() external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
}
}
| _mintAmount+nft<=maxMintAmountPerTx,"Exceeds max per transaction." | 507,700 | _mintAmount+nft<=maxMintAmountPerTx |
"Reached maximum capacity of No Nos in the Spaceship!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/*
.-') _ .-') _ .-')
( OO ) ) ( OO ) ) ( OO ).
,--./ ,--,' .-'),-----. ,--./ ,--,' .-'),-----. (_)---\_)
| \ | |\ ( OO' .-. ' | \ | |\ ( OO' .-. '/ _ |
| \| | )/ | | | | | \| | )/ | | | |\ :` `.
| . |/ \_) | |\| | | . |/ \_) | |\| | '..`''.)
| |\ | \ | | | | | |\ | \ | | | |.-._) \
| | \ | `' '-' ' | | \ | `' '-' '\ /
`--' `--' `-----' `--' `--' `-----' `-----'
No Nos Dev - @nonos_nft
nonosnft.com
*/
contract NoNosGenesis is ERC721A, Ownable {
string private _baseTokenURI =
"https://nonos.mypinata.cloud/ipfs/QmQY4XSK6XJhYqTmtbEDDQW66TPJ2i6EvcmQJYcXMbE2SR/";
uint256 private _maxNoNos = 25;
constructor() ERC721A("NoNosGenesis", "NONOSGENESIS") {}
modifier callerIsUser() {
}
function giveawayFighter(address _to, uint256 quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(_to, quantity);
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function setMaxNoNos(uint256 _newMax) public onlyOwner {
}
function getMaxNoNos() public view returns (uint256) {
}
function withdrawAll() public onlyOwner {
}
}
| totalSupply()+quantity<=_maxNoNos,"Reached maximum capacity of No Nos in the Spaceship!" | 507,845 | totalSupply()+quantity<=_maxNoNos |
"ERC1155Token: token already exists" | pragma solidity ^0.8.0;
/**
* @title ERC1155Token
* @dev ERC1155 token contract.
*/
contract ERC1155Token is Controllable, ERC1155Supply {
using Strings for uint160;
using Strings for uint256;
string private _uriPrefix;
mapping(uint256 => uint256) private _checksums;
mapping(uint256 => bool) private _nonFungibleTokens;
event MetadataUriChanged(string indexed uriPrefix);
event MetadataChecksumChanged(uint256 indexed identifier, uint256 indexed checksum);
event MetadataChecksumBatchChanged(uint256[] indexed identifiers, uint256[] indexed checksums);
/**
* @dev Creates token instance with URI prefix set to `uriPrefix`.
*/
constructor(string memory uriPrefix) ERC1155("") {
}
/**
* @dev Requires that a token with given `identifier` exists.
*/
modifier onlyExistingToken(uint256 identifier) {
}
/**
* @dev Allows to mint non-fungible token identified by `identifier` anch `checksum` by the controller and assign it to `beneficiary`.
*/
function mintNonFungible(uint256 identifier, uint256 checksum, address beneficiary) external onlyController {
require(<FILL_ME>)
_checksums[identifier] = checksum;
_nonFungibleTokens[identifier] = true;
_mint(beneficiary, identifier, 1, "");
emit MetadataChecksumChanged(identifier, checksum);
}
/**
* @dev Allows to mint multiple non-fungible tokens identified by `identifiers` and `checksums` by the controller and assign them to `beneficiary`.
*/
function mintNonFungibleBatch(uint256[] calldata identifiers, uint256[] calldata checksums, address beneficiary) external onlyController {
}
/**
* @dev Sets metadata URI prefix to `uriPrefix`.
*/
function setMetadataUriPrefix(string calldata uriPrefix) external onlyOwner {
}
/**
* @dev Sets metadata checksum for given `identifier` to `checksum`.
*/
function setMetadataChecksum(uint256 identifier, uint256 checksum) external onlyOwner onlyExistingToken(identifier) {
}
/**
* @dev Sets metadata checksums for given `identifiers` to `checksums`.
*/
function setMetadataChecksumBatch(uint256[] calldata identifiers, uint256[] calldata checksums) external onlyOwner {
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override onlyExistingToken(identifier) returns (string memory) {
}
/**
* @dev Returns metadata checksum for given `identifier`.
*/
function metadataChecksum(uint256 identifier) external view onlyExistingToken(identifier) returns (string memory) {
}
}
| !exists(identifier),"ERC1155Token: token already exists" | 507,993 | !exists(identifier) |
"ERC1155Token: token already exists" | pragma solidity ^0.8.0;
/**
* @title ERC1155Token
* @dev ERC1155 token contract.
*/
contract ERC1155Token is Controllable, ERC1155Supply {
using Strings for uint160;
using Strings for uint256;
string private _uriPrefix;
mapping(uint256 => uint256) private _checksums;
mapping(uint256 => bool) private _nonFungibleTokens;
event MetadataUriChanged(string indexed uriPrefix);
event MetadataChecksumChanged(uint256 indexed identifier, uint256 indexed checksum);
event MetadataChecksumBatchChanged(uint256[] indexed identifiers, uint256[] indexed checksums);
/**
* @dev Creates token instance with URI prefix set to `uriPrefix`.
*/
constructor(string memory uriPrefix) ERC1155("") {
}
/**
* @dev Requires that a token with given `identifier` exists.
*/
modifier onlyExistingToken(uint256 identifier) {
}
/**
* @dev Allows to mint non-fungible token identified by `identifier` anch `checksum` by the controller and assign it to `beneficiary`.
*/
function mintNonFungible(uint256 identifier, uint256 checksum, address beneficiary) external onlyController {
}
/**
* @dev Allows to mint multiple non-fungible tokens identified by `identifiers` and `checksums` by the controller and assign them to `beneficiary`.
*/
function mintNonFungibleBatch(uint256[] calldata identifiers, uint256[] calldata checksums, address beneficiary) external onlyController {
require(identifiers.length == checksums.length, "ERC1155Token: length of identifiers and checksums must be the same");
uint256[] memory values = new uint256[](identifiers.length);
for (uint256 i = 0; i < identifiers.length; ++i) {
require(<FILL_ME>)
values[i] = 1;
_checksums[identifiers[i]] = checksums[i];
_nonFungibleTokens[identifiers[i]] = true;
}
_mintBatch(beneficiary, identifiers, values, "");
emit MetadataChecksumBatchChanged(identifiers, checksums);
}
/**
* @dev Sets metadata URI prefix to `uriPrefix`.
*/
function setMetadataUriPrefix(string calldata uriPrefix) external onlyOwner {
}
/**
* @dev Sets metadata checksum for given `identifier` to `checksum`.
*/
function setMetadataChecksum(uint256 identifier, uint256 checksum) external onlyOwner onlyExistingToken(identifier) {
}
/**
* @dev Sets metadata checksums for given `identifiers` to `checksums`.
*/
function setMetadataChecksumBatch(uint256[] calldata identifiers, uint256[] calldata checksums) external onlyOwner {
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override onlyExistingToken(identifier) returns (string memory) {
}
/**
* @dev Returns metadata checksum for given `identifier`.
*/
function metadataChecksum(uint256 identifier) external view onlyExistingToken(identifier) returns (string memory) {
}
}
| !exists(identifiers[i]),"ERC1155Token: token already exists" | 507,993 | !exists(identifiers[i]) |
"ERC1155Token: new value is the same" | pragma solidity ^0.8.0;
/**
* @title ERC1155Token
* @dev ERC1155 token contract.
*/
contract ERC1155Token is Controllable, ERC1155Supply {
using Strings for uint160;
using Strings for uint256;
string private _uriPrefix;
mapping(uint256 => uint256) private _checksums;
mapping(uint256 => bool) private _nonFungibleTokens;
event MetadataUriChanged(string indexed uriPrefix);
event MetadataChecksumChanged(uint256 indexed identifier, uint256 indexed checksum);
event MetadataChecksumBatchChanged(uint256[] indexed identifiers, uint256[] indexed checksums);
/**
* @dev Creates token instance with URI prefix set to `uriPrefix`.
*/
constructor(string memory uriPrefix) ERC1155("") {
}
/**
* @dev Requires that a token with given `identifier` exists.
*/
modifier onlyExistingToken(uint256 identifier) {
}
/**
* @dev Allows to mint non-fungible token identified by `identifier` anch `checksum` by the controller and assign it to `beneficiary`.
*/
function mintNonFungible(uint256 identifier, uint256 checksum, address beneficiary) external onlyController {
}
/**
* @dev Allows to mint multiple non-fungible tokens identified by `identifiers` and `checksums` by the controller and assign them to `beneficiary`.
*/
function mintNonFungibleBatch(uint256[] calldata identifiers, uint256[] calldata checksums, address beneficiary) external onlyController {
}
/**
* @dev Sets metadata URI prefix to `uriPrefix`.
*/
function setMetadataUriPrefix(string calldata uriPrefix) external onlyOwner {
require(<FILL_ME>)
_uriPrefix = uriPrefix;
emit MetadataUriChanged(uriPrefix);
}
/**
* @dev Sets metadata checksum for given `identifier` to `checksum`.
*/
function setMetadataChecksum(uint256 identifier, uint256 checksum) external onlyOwner onlyExistingToken(identifier) {
}
/**
* @dev Sets metadata checksums for given `identifiers` to `checksums`.
*/
function setMetadataChecksumBatch(uint256[] calldata identifiers, uint256[] calldata checksums) external onlyOwner {
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override onlyExistingToken(identifier) returns (string memory) {
}
/**
* @dev Returns metadata checksum for given `identifier`.
*/
function metadataChecksum(uint256 identifier) external view onlyExistingToken(identifier) returns (string memory) {
}
}
| keccak256(abi.encodePacked(_uriPrefix))!=keccak256(abi.encodePacked(uriPrefix)),"ERC1155Token: new value is the same" | 507,993 | keccak256(abi.encodePacked(_uriPrefix))!=keccak256(abi.encodePacked(uriPrefix)) |
"ERC1155Token: new value is the same" | pragma solidity ^0.8.0;
/**
* @title ERC1155Token
* @dev ERC1155 token contract.
*/
contract ERC1155Token is Controllable, ERC1155Supply {
using Strings for uint160;
using Strings for uint256;
string private _uriPrefix;
mapping(uint256 => uint256) private _checksums;
mapping(uint256 => bool) private _nonFungibleTokens;
event MetadataUriChanged(string indexed uriPrefix);
event MetadataChecksumChanged(uint256 indexed identifier, uint256 indexed checksum);
event MetadataChecksumBatchChanged(uint256[] indexed identifiers, uint256[] indexed checksums);
/**
* @dev Creates token instance with URI prefix set to `uriPrefix`.
*/
constructor(string memory uriPrefix) ERC1155("") {
}
/**
* @dev Requires that a token with given `identifier` exists.
*/
modifier onlyExistingToken(uint256 identifier) {
}
/**
* @dev Allows to mint non-fungible token identified by `identifier` anch `checksum` by the controller and assign it to `beneficiary`.
*/
function mintNonFungible(uint256 identifier, uint256 checksum, address beneficiary) external onlyController {
}
/**
* @dev Allows to mint multiple non-fungible tokens identified by `identifiers` and `checksums` by the controller and assign them to `beneficiary`.
*/
function mintNonFungibleBatch(uint256[] calldata identifiers, uint256[] calldata checksums, address beneficiary) external onlyController {
}
/**
* @dev Sets metadata URI prefix to `uriPrefix`.
*/
function setMetadataUriPrefix(string calldata uriPrefix) external onlyOwner {
}
/**
* @dev Sets metadata checksum for given `identifier` to `checksum`.
*/
function setMetadataChecksum(uint256 identifier, uint256 checksum) external onlyOwner onlyExistingToken(identifier) {
require(<FILL_ME>)
_checksums[identifier] = checksum;
emit MetadataChecksumChanged(identifier, checksum);
}
/**
* @dev Sets metadata checksums for given `identifiers` to `checksums`.
*/
function setMetadataChecksumBatch(uint256[] calldata identifiers, uint256[] calldata checksums) external onlyOwner {
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override onlyExistingToken(identifier) returns (string memory) {
}
/**
* @dev Returns metadata checksum for given `identifier`.
*/
function metadataChecksum(uint256 identifier) external view onlyExistingToken(identifier) returns (string memory) {
}
}
| _checksums[identifier]!=checksum,"ERC1155Token: new value is the same" | 507,993 | _checksums[identifier]!=checksum |
"ERC1155Token: token with given identifier does not exist" | pragma solidity ^0.8.0;
/**
* @title ERC1155Token
* @dev ERC1155 token contract.
*/
contract ERC1155Token is Controllable, ERC1155Supply {
using Strings for uint160;
using Strings for uint256;
string private _uriPrefix;
mapping(uint256 => uint256) private _checksums;
mapping(uint256 => bool) private _nonFungibleTokens;
event MetadataUriChanged(string indexed uriPrefix);
event MetadataChecksumChanged(uint256 indexed identifier, uint256 indexed checksum);
event MetadataChecksumBatchChanged(uint256[] indexed identifiers, uint256[] indexed checksums);
/**
* @dev Creates token instance with URI prefix set to `uriPrefix`.
*/
constructor(string memory uriPrefix) ERC1155("") {
}
/**
* @dev Requires that a token with given `identifier` exists.
*/
modifier onlyExistingToken(uint256 identifier) {
}
/**
* @dev Allows to mint non-fungible token identified by `identifier` anch `checksum` by the controller and assign it to `beneficiary`.
*/
function mintNonFungible(uint256 identifier, uint256 checksum, address beneficiary) external onlyController {
}
/**
* @dev Allows to mint multiple non-fungible tokens identified by `identifiers` and `checksums` by the controller and assign them to `beneficiary`.
*/
function mintNonFungibleBatch(uint256[] calldata identifiers, uint256[] calldata checksums, address beneficiary) external onlyController {
}
/**
* @dev Sets metadata URI prefix to `uriPrefix`.
*/
function setMetadataUriPrefix(string calldata uriPrefix) external onlyOwner {
}
/**
* @dev Sets metadata checksum for given `identifier` to `checksum`.
*/
function setMetadataChecksum(uint256 identifier, uint256 checksum) external onlyOwner onlyExistingToken(identifier) {
}
/**
* @dev Sets metadata checksums for given `identifiers` to `checksums`.
*/
function setMetadataChecksumBatch(uint256[] calldata identifiers, uint256[] calldata checksums) external onlyOwner {
require(identifiers.length == checksums.length, "ERC1155Token: length of identifiers and checksums must be the same");
for (uint256 i = 0; i < identifiers.length; ++i) {
require(<FILL_ME>)
require(_checksums[identifiers[i]] != checksums[i], "ERC1155Token: new value is the same");
_checksums[identifiers[i]] = checksums[i];
}
emit MetadataChecksumBatchChanged(identifiers, checksums);
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override onlyExistingToken(identifier) returns (string memory) {
}
/**
* @dev Returns metadata checksum for given `identifier`.
*/
function metadataChecksum(uint256 identifier) external view onlyExistingToken(identifier) returns (string memory) {
}
}
| exists(identifiers[i]),"ERC1155Token: token with given identifier does not exist" | 507,993 | exists(identifiers[i]) |
"ERC1155Token: new value is the same" | pragma solidity ^0.8.0;
/**
* @title ERC1155Token
* @dev ERC1155 token contract.
*/
contract ERC1155Token is Controllable, ERC1155Supply {
using Strings for uint160;
using Strings for uint256;
string private _uriPrefix;
mapping(uint256 => uint256) private _checksums;
mapping(uint256 => bool) private _nonFungibleTokens;
event MetadataUriChanged(string indexed uriPrefix);
event MetadataChecksumChanged(uint256 indexed identifier, uint256 indexed checksum);
event MetadataChecksumBatchChanged(uint256[] indexed identifiers, uint256[] indexed checksums);
/**
* @dev Creates token instance with URI prefix set to `uriPrefix`.
*/
constructor(string memory uriPrefix) ERC1155("") {
}
/**
* @dev Requires that a token with given `identifier` exists.
*/
modifier onlyExistingToken(uint256 identifier) {
}
/**
* @dev Allows to mint non-fungible token identified by `identifier` anch `checksum` by the controller and assign it to `beneficiary`.
*/
function mintNonFungible(uint256 identifier, uint256 checksum, address beneficiary) external onlyController {
}
/**
* @dev Allows to mint multiple non-fungible tokens identified by `identifiers` and `checksums` by the controller and assign them to `beneficiary`.
*/
function mintNonFungibleBatch(uint256[] calldata identifiers, uint256[] calldata checksums, address beneficiary) external onlyController {
}
/**
* @dev Sets metadata URI prefix to `uriPrefix`.
*/
function setMetadataUriPrefix(string calldata uriPrefix) external onlyOwner {
}
/**
* @dev Sets metadata checksum for given `identifier` to `checksum`.
*/
function setMetadataChecksum(uint256 identifier, uint256 checksum) external onlyOwner onlyExistingToken(identifier) {
}
/**
* @dev Sets metadata checksums for given `identifiers` to `checksums`.
*/
function setMetadataChecksumBatch(uint256[] calldata identifiers, uint256[] calldata checksums) external onlyOwner {
require(identifiers.length == checksums.length, "ERC1155Token: length of identifiers and checksums must be the same");
for (uint256 i = 0; i < identifiers.length; ++i) {
require(exists(identifiers[i]), "ERC1155Token: token with given identifier does not exist");
require(<FILL_ME>)
_checksums[identifiers[i]] = checksums[i];
}
emit MetadataChecksumBatchChanged(identifiers, checksums);
}
/**
* @dev Returns metadata URI for given `identifier`.
*/
function uri(uint256 identifier) public view override onlyExistingToken(identifier) returns (string memory) {
}
/**
* @dev Returns metadata checksum for given `identifier`.
*/
function metadataChecksum(uint256 identifier) external view onlyExistingToken(identifier) returns (string memory) {
}
}
| _checksums[identifiers[i]]!=checksums[i],"ERC1155Token: new value is the same" | 507,993 | _checksums[identifiers[i]]!=checksums[i] |
"GenArtERC721AI: sender is not membership owner" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/interfaces/IERC165.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";
import "@openzeppelin/contracts/interfaces/IERC20.sol";
import "./GenArtAccess.sol";
import "./MintStateReserveGold.sol";
import "./IGenArtMembership.sol";
import "./IGenArtPaymentSplitterV2.sol";
import "./IGenArtInterfaceV3.sol";
/**
* @dev GEN.ART ERC721 V2
* Implements the extentions {IERC721Enumerable} and {IERC2981}.
* Inherits access control from {GenArtAccess}.
* Sends all ETH to a {PaymentSplitter} contract.
* Restricts minting to GEN.ART Membership holders.
* IMPORTANT: This implementation requires the royalties to be send to the contracts address
* in order to split the funds between payees automatically.
*/
contract GenArtERC721AI is ERC721Enumerable, GenArtAccess, IERC2981 {
using Strings for uint256;
using MintStateReserveGold for MintStateReserveGold.State;
uint256 public _mintPrice;
uint256 public _mintSupply;
address public _royaltyReceiver = address(this);
uint256 public _collectionId;
bool private _reservedMinted;
address public _genartInterface;
address public _paymentSplitter;
address public _wethAddress;
string private _uri;
bool public _paused = true;
MintStateReserveGold.State public _mintstate;
/**
*@dev Emitted on mint
*/
event Mint(
uint256 tokenId,
uint256 collectionId,
uint256 membershipId,
address to
);
constructor(
string memory name_,
string memory symbol_,
string memory uri_,
uint256 collectionId_,
uint256 mintPrice_,
uint256 mintSupply_,
address genartInterface_,
address paymentSplitter_,
address wethAddress_
) ERC721(name_, symbol_) GenArtAccess() {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721Enumerable, IERC165)
returns (bool)
{
}
/**
*@dev Get amount of mints for a membershipId
*/
function getMembershipMints(uint256 membershipId)
public
view
returns (uint256)
{
}
/**
*@dev Get available mints for a membershipId
*/
function getAvailableMintsForMembership(uint256 membershipId)
public
view
returns (uint256)
{
}
/**
*@dev Check if minter has available mint slots and has sent the required amount of ETH
* Revert in case minting is paused or checks fail.
*/
function checkMint(uint256 amount, uint256 availableMints) internal view {
}
/**
*@dev Public function to mint the desired amount of tokens
* Requirments:
* - sender must be GEN.ART Membership owner
*/
function mint(address to, uint256 amount) public payable {
}
/**
*@dev Public function to mint one token for a GEN.ART Membership
* Requirments:
* - sender must own the membership
*/
function mintOne(address to, uint256 membershipId) public payable {
// check if sender is owner of membership
require(<FILL_ME>)
// get available mints for membership
uint256 availableMints = getAvailableMintsForMembership(membershipId);
checkMint(1, availableMints);
bool isGold = IGenArtInterfaceV3(_genartInterface).isGoldToken(
membershipId
);
// mint token
mintForMembership(to, membershipId, isGold);
// send funds to PaymentSplitter
IGenArtPaymentSplitterV2(_paymentSplitter).splitPayment{
value: msg.value
}(address(this));
}
/**
*@dev Mint token for membership
*/
function mintForMembership(
address to,
uint256 membershipId,
bool isGold
) internal {
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
* Emits a {Mint} event.
*/
function _mintOne(address to, uint256 membershipId) internal virtual {
}
function burn(uint256 tokenId) public {
}
/**
* @dev Get royalty info see {IERC2981}
*/
function royaltyInfo(uint256, uint256 salePrice_)
external
view
virtual
override
returns (address, uint256)
{
}
/**
*@dev Get all tokens owned by an address
*/
function getTokensByOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
/**
*@dev Release WETH royalties and send them to {PaymentSplitter}
*/
function releaseWETHRoyalties() public {
}
/**
*@dev Pause and unpause minting
*/
function setPaused(bool paused) public onlyAdmin {
}
/**
*@dev Set reserved mints for gold members
*/
function setReservedGold(uint8 reserved) public onlyGenArtAdmin {
}
/**
*@dev Reserved mints can only be called by admins
* Only one possible mint.
*/
function mintReserved() public onlyAdmin {
}
/**
*@dev Set {PaymentSplitter} address
*/
function setPaymentSplitter(address paymentSplitter)
public
onlyGenArtAdmin
{
}
/**
*@dev Set receiver of royalties
*/
function setRoyaltyReceiver(address receiver) public onlyGenArtAdmin {
}
/**
* @dev Set base uri
*/
function setBaseURI(string memory uri) public onlyGenArtAdmin {
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overriden in child contracts.
*/
function _baseURI() internal view virtual override returns (string memory) {
}
/**
*@dev Royalties are forwarded to {PaymentSplitter}
*/
receive() external payable {
}
}
| IGenArtInterfaceV3(_genartInterface).ownerOfMembership(membershipId)==_msgSender(),"GenArtERC721AI: sender is not membership owner" | 508,010 | IGenArtInterfaceV3(_genartInterface).ownerOfMembership(membershipId)==_msgSender() |
"Wallet amount exceed max wallet amount" | /*
Track you memecoins portfolio at your fingertips !
Twitter : https://twitter.com/madaraapp
Telegram : https://t.me/madaraapp
Medium : https://medium.com/@MadaraApp
Website : https://www.madara.app
*/
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
contract Madara is Context, IERC20, Ownable {
using SafeMath for uint256;
// allowances and balances
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) private _balances;
// tax
address payable private _marketingWallet = payable(0x34A91e6fD78ABf93f10c370c184E1be4970933d3);
mapping (address => bool) private _isExcludedFromFee;
uint8 private _marketingTax = 3;
uint8 private _burnTax = 1;
uint8 private _totalTax = _marketingTax + _burnTax;
// properties
string public constant _name = "MADARA";
string public constant _symbol = "MAD";
uint8 public constant _decimals = 18;
uint256 public _supply = 1_000_000_000 * 10 ** _decimals;
uint256 public _maxTxAmount = _supply * 3 / 100; // 3%
uint256 public _maxWalletAmount = _supply * 3 / 100; // 3%
// anti-bot
bool tradingEnabled = false;
uint256 enabledBlockNumber = 0;
mapping (address => bool) private _isBlacklisted;
// DEX
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
// utilities
bool private inSwap = false;
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 view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function enableTrading() external onlyOwner {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
if (!_isExcludedFromFee[recipient] && !_isExcludedFromFee[sender]) {
require(tradingEnabled, "Trading is not enabled yet");
require(amount <= _maxTxAmount, "Transfer amount exceed max tx amount");
require(<FILL_ME>)
if (block.number + 3 < enabledBlockNumber) {
_isBlacklisted[recipient] = true;
}
if (!_isBlacklisted[recipient] && !_isBlacklisted[sender]) {
// 3% marketing tax + 1% burn
uint256 totalTaxAmount = amount.mul(_totalTax).div(100);
// proceed to transfer
uint256 amountToTransfer = amount.sub(totalTaxAmount);
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amountToTransfer);
// transfer marketing tax
uint256 marketingTaxAmount = amount.mul(_marketingTax).div(100);
_balances[address(this)] = _balances[address(this)].add(marketingTaxAmount);
// burn amount remaining from tax (1%)
_burnFromTax(sender, totalTaxAmount.sub(marketingTaxAmount));
}
} else {
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToMarketing(uint256 amount) private {
}
function _burnFromTax(address sender, uint256 amount) private {
}
function burn(uint256 amount) public returns (bool) {
}
receive() external payable {}
function manualswap() external {
}
function manualsend() external {
}
}
| _balances[recipient].add(amount)<_maxWalletAmount,"Wallet amount exceed max wallet amount" | 508,074 | _balances[recipient].add(amount)<_maxWalletAmount |
'Over Max Supply' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './IERC5192.sol';
contract TukuruERC721 is ERC721, AccessControl, Ownable, Pausable, IERC5192, ERC2981 {
using Strings for uint256;
// Role
bytes32 public constant ADMIN = "ADMIN";
bytes32 public constant MINTER = "MINTER";
// Metadata
string private _name;
string private _symbol;
string public baseURI;
string public baseExtension;
// Mint
uint256 public mintCost;
uint256 public maxSupply;
uint256 public totalSupply;
bool public isLocked;
// Withdraw
uint256 public usageFee = 0.1 ether;
address public withdrawAddress;
uint256 public systemRoyalty;
address public royaltyReceiver;
// Modifier
modifier withinMaxSupply(uint256 _amount) {
require(<FILL_ME>)
_;
}
modifier enoughEth(uint256 _amount) {
}
// Constructor
constructor() ERC721("", "") Ownable(msg.sender) {
}
function initialize (
address _owner,
string memory _erc721Name,
string memory _src721Symbol,
bool _isLocked,
uint96 _royaltyFee,
address _withdrawAddress,
uint256 _systemRoyalty,
address _royaltyReceiver
) external {
}
function updateToNoSystemRoyalty() external payable {
}
// Mint
function airdrop(address[] calldata _addresses, uint256[] calldata _tokenIds) external onlyRole(ADMIN) {
}
function mint(address _address, uint256[] calldata _tokenIds) external payable onlyRole(MINTER)
whenNotPaused
withinMaxSupply(_tokenIds.length)
enoughEth(_tokenIds.length)
{
}
function externalMint(address _address, uint256[] calldata _tokenIds) external onlyRole(MINTER) {
}
function mintCommon(address _address, uint256 _tokenId) private {
}
function withdraw() public onlyRole(ADMIN) {
}
// Getter
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 getBalance() public view returns (uint256) {
}
// Setter
function setWithdrawAddress(address _value) public onlyRole(ADMIN) {
}
function setMetadataBase(string memory _baseURI, string memory _baseExtension) external onlyRole(ADMIN) {
}
function setIsLocked(bool _isLocked) external onlyRole(ADMIN) {
}
function setSalesInfo(uint256 _mintCost, uint256 _maxSupply) external onlyRole(ADMIN) {
}
// Pause
function setPause(bool _value) external onlyRole(ADMIN) {
}
// interface
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, AccessControl, ERC2981) returns (bool) {
}
// Transfer
function locked(uint256) override public view returns (bool){
}
function emitLockState(uint256 _tokenId, bool _locked) external onlyRole(ADMIN) {
}
function setApprovalForAll(address _operator, bool _approved) public virtual override {
}
function approve(address _to, uint256 _tokenId) public virtual override {
}
function _update(address _to, uint256 _tokenId, address _auth) internal virtual override returns (address) {
}
}
| totalSupply+_amount<=maxSupply,'Over Max Supply' | 508,084 | totalSupply+_amount<=maxSupply |
"Locked" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import './IERC5192.sol';
contract TukuruERC721 is ERC721, AccessControl, Ownable, Pausable, IERC5192, ERC2981 {
using Strings for uint256;
// Role
bytes32 public constant ADMIN = "ADMIN";
bytes32 public constant MINTER = "MINTER";
// Metadata
string private _name;
string private _symbol;
string public baseURI;
string public baseExtension;
// Mint
uint256 public mintCost;
uint256 public maxSupply;
uint256 public totalSupply;
bool public isLocked;
// Withdraw
uint256 public usageFee = 0.1 ether;
address public withdrawAddress;
uint256 public systemRoyalty;
address public royaltyReceiver;
// Modifier
modifier withinMaxSupply(uint256 _amount) {
}
modifier enoughEth(uint256 _amount) {
}
// Constructor
constructor() ERC721("", "") Ownable(msg.sender) {
}
function initialize (
address _owner,
string memory _erc721Name,
string memory _src721Symbol,
bool _isLocked,
uint96 _royaltyFee,
address _withdrawAddress,
uint256 _systemRoyalty,
address _royaltyReceiver
) external {
}
function updateToNoSystemRoyalty() external payable {
}
// Mint
function airdrop(address[] calldata _addresses, uint256[] calldata _tokenIds) external onlyRole(ADMIN) {
}
function mint(address _address, uint256[] calldata _tokenIds) external payable onlyRole(MINTER)
whenNotPaused
withinMaxSupply(_tokenIds.length)
enoughEth(_tokenIds.length)
{
}
function externalMint(address _address, uint256[] calldata _tokenIds) external onlyRole(MINTER) {
}
function mintCommon(address _address, uint256 _tokenId) private {
}
function withdraw() public onlyRole(ADMIN) {
}
// Getter
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 getBalance() public view returns (uint256) {
}
// Setter
function setWithdrawAddress(address _value) public onlyRole(ADMIN) {
}
function setMetadataBase(string memory _baseURI, string memory _baseExtension) external onlyRole(ADMIN) {
}
function setIsLocked(bool _isLocked) external onlyRole(ADMIN) {
}
function setSalesInfo(uint256 _mintCost, uint256 _maxSupply) external onlyRole(ADMIN) {
}
// Pause
function setPause(bool _value) external onlyRole(ADMIN) {
}
// interface
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, AccessControl, ERC2981) returns (bool) {
}
// Transfer
function locked(uint256) override public view returns (bool){
}
function emitLockState(uint256 _tokenId, bool _locked) external onlyRole(ADMIN) {
}
function setApprovalForAll(address _operator, bool _approved) public virtual override {
require(<FILL_ME>)
super.setApprovalForAll(_operator, _approved);
}
function approve(address _to, uint256 _tokenId) public virtual override {
}
function _update(address _to, uint256 _tokenId, address _auth) internal virtual override returns (address) {
}
}
| !_approved||!isLocked,"Locked" | 508,084 | !_approved||!isLocked |
"EXCEEDS MAX CLAIM" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
MM
MMMM
MMMMM
MMMMMM MM
MMM MMM
MMMMM
M MMMMMMMMMM MMMMMM
MMMM MMMMMMMMMMMMM MMMM
MMMMMM MMMMMMMMMMMMMM MM
MMMMMM MMMMMMMMMMMMMMM MMMMMMMMMM
MMMM MMMMMMMMMMMMMMM MMMMMMMMMMMM
MMMM MMMMMMMMMMMMMMM MMMMMMMMMMMMM
MMMMMMMMMMM MMMMMMMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMM MMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM MMMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMM MMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMMM MMMMMMM
MM MMMMMMMMMMMMMMMM
MMMM MMMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMM MMM MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMM MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMM
M MMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
M MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM
MMMMMMMM MMM
MMMMMM M
MMMMMM
MMMMM
MMMMM
MMMMM
MMMM
MM
*/
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MutantShibaClub is ERC721A, Ownable {
using Strings for uint256;
// ======== SUPPLY ========
uint256 public constant MAX_SUPPLY = 10000;
// ======== MAX MINTS ========
uint256 public maxCommunityMint = 1;
uint256 public maxPublicSaleMint = 1;
// ======== PRICE ========
uint256 public publicSalePrice;
uint256 public communitySalePrice;
uint256 public preSalePrice = 0.16 ether;
uint256 public teamMintPrice = 0.1 ether;
// ======== SALE STATUS ========
bool public isPreSaleActive;
bool public isCommunitySaleActive;
bool public isPublicSaleActive;
// ======== METADATA ========
bool public isRevealed;
string private _baseTokenURI;
// ======== MERKLE ROOT ========
bytes32 public preSaleMerkleRoot;
bytes32 public communitySaleMerkleRoot;
// ======== MINTED ========
mapping(address => uint256) public preSaleMinted;
mapping(address => bool) public communitySaleMinted;
mapping(address => uint256) public publicSaleMinted;
// ======== GNOSIS ========
address public constant GNOSIS_SAFE = 0xe16B650921475afA532f7C08A8eA1C2fCDa8ab93;
// ======== FOUNDERS & TEAM ========
address public constant TEAM = 0xcdBB9a281f1086aEcB6c4d5ac290130c1A8778De;
address public constant FOUNDER_BERRY = 0x28C1dEd0D767fDC39530f676362175afe35E96B4;
address public constant FOUNDER_GABA = 0xbe14e8d7a3417046627f305C918eC435C3c23fbC;
address public constant FOUNDER_LORDSLABS = 0xbb59f8ce665d238A9e8D942172D283ba87061F6F;
address public constant FOUNDER_CRAZYJUMP = 0xE386aE197A42e49C727BF15070FE71C68F18ad45;
// ======== CONSTRUCTOR ========
constructor() ERC721A("Mutant Shiba Club", "MSC") {}
/**
* @notice must be an EOA
*/
modifier callerIsUser() {
}
// ======== MINTING ========
/**
* @notice presale mint
*/
function preSaleMint(uint256 _quantity, uint256 _maxAmount, bytes32[] calldata _proof) external payable callerIsUser {
require(isPreSaleActive, "PRESALE NOT ACTIVE");
require(msg.value == preSalePrice * _quantity, "NEED TO SEND CORRECT ETH AMOUNT");
require(totalSupply() + _quantity <= MAX_SUPPLY, "MAX SUPPLY REACHED" );
require(<FILL_ME>)
bytes32 sender = keccak256(abi.encodePacked(msg.sender, _maxAmount));
bool isValidProof = MerkleProof.verify(_proof, preSaleMerkleRoot, sender);
require(isValidProof, "INVALID PROOF");
preSaleMinted[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
/**
* @notice community sale mint
*/
function communitySaleMint(bytes32[] calldata _proof) external payable callerIsUser {
}
/**
* @notice public sale mint
*/
function publicSaleMint(uint256 _quantity) external payable callerIsUser {
}
function teamMint(uint256 _quantity, bool _founders) external payable onlyOwner {
}
// ======== SALE STATUS SETTERS ========
/**
* @notice activating or deactivating presale status
*/
function setPreSaleStatus(bool _status) external onlyOwner {
}
/**
* @notice activating or deactivating community sale status
*/
function setCommunitySaleStatus(bool _status) external onlyOwner {
}
/**
* @notice activating or deactivating public sale
*/
function setPublicSaleStatus(bool _status) external onlyOwner {
}
// ======== PRICE SETTERS ========
/**
* @notice set presale price
*/
function setPreSalePrice(uint256 _price) external onlyOwner {
}
/**
* @notice set whitelist price
*/
function setCommunitySalePrice(uint256 _price) external onlyOwner {
}
/**
* @notice set public sale price
*/
function setPublicSalePrice(uint256 _price) external onlyOwner {
}
// ======== MERKLE ROOT SETTERS ========
/**
* @notice set presale merkleroot
*/
function setPresaleMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice set community sale merkleroot
*/
function setCommunitySaleMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
// ======== METADATA URI ========
/**
* @notice tokenURI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/**
* @notice set IsRevealed to true or false
*/
function setIsRevealed(bool _reveal) external onlyOwner {
}
/**
* @notice set startTokenId to 1
*/
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// ======== WITHDRAW GNOSIS ========
/**
* @notice withdraw funds to gnosis safe
*/
function withdraw() external onlyOwner {
}
}
| preSaleMinted[msg.sender]+_quantity<=_maxAmount,"EXCEEDS MAX CLAIM" | 508,141 | preSaleMinted[msg.sender]+_quantity<=_maxAmount |
"MAX SUPPLY REACHED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
MM
MMMM
MMMMM
MMMMMM MM
MMM MMM
MMMMM
M MMMMMMMMMM MMMMMM
MMMM MMMMMMMMMMMMM MMMM
MMMMMM MMMMMMMMMMMMMM MM
MMMMMM MMMMMMMMMMMMMMM MMMMMMMMMM
MMMM MMMMMMMMMMMMMMM MMMMMMMMMMMM
MMMM MMMMMMMMMMMMMMM MMMMMMMMMMMMM
MMMMMMMMMMM MMMMMMMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMM MMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM MMMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMM MMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMMM MMMMMMM
MM MMMMMMMMMMMMMMMM
MMMM MMMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMM MMM MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMM MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMM
M MMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
M MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM
MMMMMMMM MMM
MMMMMM M
MMMMMM
MMMMM
MMMMM
MMMMM
MMMM
MM
*/
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MutantShibaClub is ERC721A, Ownable {
using Strings for uint256;
// ======== SUPPLY ========
uint256 public constant MAX_SUPPLY = 10000;
// ======== MAX MINTS ========
uint256 public maxCommunityMint = 1;
uint256 public maxPublicSaleMint = 1;
// ======== PRICE ========
uint256 public publicSalePrice;
uint256 public communitySalePrice;
uint256 public preSalePrice = 0.16 ether;
uint256 public teamMintPrice = 0.1 ether;
// ======== SALE STATUS ========
bool public isPreSaleActive;
bool public isCommunitySaleActive;
bool public isPublicSaleActive;
// ======== METADATA ========
bool public isRevealed;
string private _baseTokenURI;
// ======== MERKLE ROOT ========
bytes32 public preSaleMerkleRoot;
bytes32 public communitySaleMerkleRoot;
// ======== MINTED ========
mapping(address => uint256) public preSaleMinted;
mapping(address => bool) public communitySaleMinted;
mapping(address => uint256) public publicSaleMinted;
// ======== GNOSIS ========
address public constant GNOSIS_SAFE = 0xe16B650921475afA532f7C08A8eA1C2fCDa8ab93;
// ======== FOUNDERS & TEAM ========
address public constant TEAM = 0xcdBB9a281f1086aEcB6c4d5ac290130c1A8778De;
address public constant FOUNDER_BERRY = 0x28C1dEd0D767fDC39530f676362175afe35E96B4;
address public constant FOUNDER_GABA = 0xbe14e8d7a3417046627f305C918eC435C3c23fbC;
address public constant FOUNDER_LORDSLABS = 0xbb59f8ce665d238A9e8D942172D283ba87061F6F;
address public constant FOUNDER_CRAZYJUMP = 0xE386aE197A42e49C727BF15070FE71C68F18ad45;
// ======== CONSTRUCTOR ========
constructor() ERC721A("Mutant Shiba Club", "MSC") {}
/**
* @notice must be an EOA
*/
modifier callerIsUser() {
}
// ======== MINTING ========
/**
* @notice presale mint
*/
function preSaleMint(uint256 _quantity, uint256 _maxAmount, bytes32[] calldata _proof) external payable callerIsUser {
}
/**
* @notice community sale mint
*/
function communitySaleMint(bytes32[] calldata _proof) external payable callerIsUser {
require(isCommunitySaleActive, "COMMUNITY SALE NOT ACTIVE");
require(msg.value == communitySalePrice, "NEED TO SEND CORRECT ETH AMOUNT");
require(<FILL_ME>)
require(!communitySaleMinted[msg.sender], "EXCEEDS MAX CLAIM");
bytes32 sender = keccak256(abi.encodePacked(msg.sender));
bool isValidProof = MerkleProof.verify(_proof, communitySaleMerkleRoot, sender);
require(isValidProof, "INVALID PROOF");
communitySaleMinted[msg.sender] = true;
_safeMint(msg.sender, maxCommunityMint);
}
/**
* @notice public sale mint
*/
function publicSaleMint(uint256 _quantity) external payable callerIsUser {
}
function teamMint(uint256 _quantity, bool _founders) external payable onlyOwner {
}
// ======== SALE STATUS SETTERS ========
/**
* @notice activating or deactivating presale status
*/
function setPreSaleStatus(bool _status) external onlyOwner {
}
/**
* @notice activating or deactivating community sale status
*/
function setCommunitySaleStatus(bool _status) external onlyOwner {
}
/**
* @notice activating or deactivating public sale
*/
function setPublicSaleStatus(bool _status) external onlyOwner {
}
// ======== PRICE SETTERS ========
/**
* @notice set presale price
*/
function setPreSalePrice(uint256 _price) external onlyOwner {
}
/**
* @notice set whitelist price
*/
function setCommunitySalePrice(uint256 _price) external onlyOwner {
}
/**
* @notice set public sale price
*/
function setPublicSalePrice(uint256 _price) external onlyOwner {
}
// ======== MERKLE ROOT SETTERS ========
/**
* @notice set presale merkleroot
*/
function setPresaleMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice set community sale merkleroot
*/
function setCommunitySaleMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
// ======== METADATA URI ========
/**
* @notice tokenURI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/**
* @notice set IsRevealed to true or false
*/
function setIsRevealed(bool _reveal) external onlyOwner {
}
/**
* @notice set startTokenId to 1
*/
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// ======== WITHDRAW GNOSIS ========
/**
* @notice withdraw funds to gnosis safe
*/
function withdraw() external onlyOwner {
}
}
| totalSupply()+maxCommunityMint<=MAX_SUPPLY,"MAX SUPPLY REACHED" | 508,141 | totalSupply()+maxCommunityMint<=MAX_SUPPLY |
"EXCEEDS MAX CLAIM" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
MM
MMMM
MMMMM
MMMMMM MM
MMM MMM
MMMMM
M MMMMMMMMMM MMMMMM
MMMM MMMMMMMMMMMMM MMMM
MMMMMM MMMMMMMMMMMMMM MM
MMMMMM MMMMMMMMMMMMMMM MMMMMMMMMM
MMMM MMMMMMMMMMMMMMM MMMMMMMMMMMM
MMMM MMMMMMMMMMMMMMM MMMMMMMMMMMMM
MMMMMMMMMMM MMMMMMMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMM MMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM MMMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMM MMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMMM MMMMMMM
MM MMMMMMMMMMMMMMMM
MMMM MMMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMM MMM MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMM MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMM
M MMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
M MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM
MMMMMMMM MMM
MMMMMM M
MMMMMM
MMMMM
MMMMM
MMMMM
MMMM
MM
*/
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MutantShibaClub is ERC721A, Ownable {
using Strings for uint256;
// ======== SUPPLY ========
uint256 public constant MAX_SUPPLY = 10000;
// ======== MAX MINTS ========
uint256 public maxCommunityMint = 1;
uint256 public maxPublicSaleMint = 1;
// ======== PRICE ========
uint256 public publicSalePrice;
uint256 public communitySalePrice;
uint256 public preSalePrice = 0.16 ether;
uint256 public teamMintPrice = 0.1 ether;
// ======== SALE STATUS ========
bool public isPreSaleActive;
bool public isCommunitySaleActive;
bool public isPublicSaleActive;
// ======== METADATA ========
bool public isRevealed;
string private _baseTokenURI;
// ======== MERKLE ROOT ========
bytes32 public preSaleMerkleRoot;
bytes32 public communitySaleMerkleRoot;
// ======== MINTED ========
mapping(address => uint256) public preSaleMinted;
mapping(address => bool) public communitySaleMinted;
mapping(address => uint256) public publicSaleMinted;
// ======== GNOSIS ========
address public constant GNOSIS_SAFE = 0xe16B650921475afA532f7C08A8eA1C2fCDa8ab93;
// ======== FOUNDERS & TEAM ========
address public constant TEAM = 0xcdBB9a281f1086aEcB6c4d5ac290130c1A8778De;
address public constant FOUNDER_BERRY = 0x28C1dEd0D767fDC39530f676362175afe35E96B4;
address public constant FOUNDER_GABA = 0xbe14e8d7a3417046627f305C918eC435C3c23fbC;
address public constant FOUNDER_LORDSLABS = 0xbb59f8ce665d238A9e8D942172D283ba87061F6F;
address public constant FOUNDER_CRAZYJUMP = 0xE386aE197A42e49C727BF15070FE71C68F18ad45;
// ======== CONSTRUCTOR ========
constructor() ERC721A("Mutant Shiba Club", "MSC") {}
/**
* @notice must be an EOA
*/
modifier callerIsUser() {
}
// ======== MINTING ========
/**
* @notice presale mint
*/
function preSaleMint(uint256 _quantity, uint256 _maxAmount, bytes32[] calldata _proof) external payable callerIsUser {
}
/**
* @notice community sale mint
*/
function communitySaleMint(bytes32[] calldata _proof) external payable callerIsUser {
require(isCommunitySaleActive, "COMMUNITY SALE NOT ACTIVE");
require(msg.value == communitySalePrice, "NEED TO SEND CORRECT ETH AMOUNT");
require(totalSupply() + maxCommunityMint <= MAX_SUPPLY, "MAX SUPPLY REACHED" );
require(<FILL_ME>)
bytes32 sender = keccak256(abi.encodePacked(msg.sender));
bool isValidProof = MerkleProof.verify(_proof, communitySaleMerkleRoot, sender);
require(isValidProof, "INVALID PROOF");
communitySaleMinted[msg.sender] = true;
_safeMint(msg.sender, maxCommunityMint);
}
/**
* @notice public sale mint
*/
function publicSaleMint(uint256 _quantity) external payable callerIsUser {
}
function teamMint(uint256 _quantity, bool _founders) external payable onlyOwner {
}
// ======== SALE STATUS SETTERS ========
/**
* @notice activating or deactivating presale status
*/
function setPreSaleStatus(bool _status) external onlyOwner {
}
/**
* @notice activating or deactivating community sale status
*/
function setCommunitySaleStatus(bool _status) external onlyOwner {
}
/**
* @notice activating or deactivating public sale
*/
function setPublicSaleStatus(bool _status) external onlyOwner {
}
// ======== PRICE SETTERS ========
/**
* @notice set presale price
*/
function setPreSalePrice(uint256 _price) external onlyOwner {
}
/**
* @notice set whitelist price
*/
function setCommunitySalePrice(uint256 _price) external onlyOwner {
}
/**
* @notice set public sale price
*/
function setPublicSalePrice(uint256 _price) external onlyOwner {
}
// ======== MERKLE ROOT SETTERS ========
/**
* @notice set presale merkleroot
*/
function setPresaleMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice set community sale merkleroot
*/
function setCommunitySaleMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
// ======== METADATA URI ========
/**
* @notice tokenURI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/**
* @notice set IsRevealed to true or false
*/
function setIsRevealed(bool _reveal) external onlyOwner {
}
/**
* @notice set startTokenId to 1
*/
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// ======== WITHDRAW GNOSIS ========
/**
* @notice withdraw funds to gnosis safe
*/
function withdraw() external onlyOwner {
}
}
| !communitySaleMinted[msg.sender],"EXCEEDS MAX CLAIM" | 508,141 | !communitySaleMinted[msg.sender] |
"EXCEEDS MAX MINTS PER ADDRESS" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/*
MM
MMMM
MMMMM
MMMMMM MM
MMM MMM
MMMMM
M MMMMMMMMMM MMMMMM
MMMM MMMMMMMMMMMMM MMMM
MMMMMM MMMMMMMMMMMMMM MM
MMMMMM MMMMMMMMMMMMMMM MMMMMMMMMM
MMMM MMMMMMMMMMMMMMM MMMMMMMMMMMM
MMMM MMMMMMMMMMMMMMM MMMMMMMMMMMMM
MMMMMMMMMMM MMMMMMMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMM MMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM MMMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMMMMMMMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMM MMM MMMMMMMMMMMMMM
MMMMMMMMMMMMMMMM MMMM MMMMMMM
MM MMMMMMMMMMMMMMMM
MMMM MMMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMM MMM MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMM MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMMM
MMMMMMMMMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM MMM
M MMM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
M MM MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMM
MMMMMMMM MMM
MMMMMM M
MMMMMM
MMMMM
MMMMM
MMMMM
MMMM
MM
*/
import "./ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract MutantShibaClub is ERC721A, Ownable {
using Strings for uint256;
// ======== SUPPLY ========
uint256 public constant MAX_SUPPLY = 10000;
// ======== MAX MINTS ========
uint256 public maxCommunityMint = 1;
uint256 public maxPublicSaleMint = 1;
// ======== PRICE ========
uint256 public publicSalePrice;
uint256 public communitySalePrice;
uint256 public preSalePrice = 0.16 ether;
uint256 public teamMintPrice = 0.1 ether;
// ======== SALE STATUS ========
bool public isPreSaleActive;
bool public isCommunitySaleActive;
bool public isPublicSaleActive;
// ======== METADATA ========
bool public isRevealed;
string private _baseTokenURI;
// ======== MERKLE ROOT ========
bytes32 public preSaleMerkleRoot;
bytes32 public communitySaleMerkleRoot;
// ======== MINTED ========
mapping(address => uint256) public preSaleMinted;
mapping(address => bool) public communitySaleMinted;
mapping(address => uint256) public publicSaleMinted;
// ======== GNOSIS ========
address public constant GNOSIS_SAFE = 0xe16B650921475afA532f7C08A8eA1C2fCDa8ab93;
// ======== FOUNDERS & TEAM ========
address public constant TEAM = 0xcdBB9a281f1086aEcB6c4d5ac290130c1A8778De;
address public constant FOUNDER_BERRY = 0x28C1dEd0D767fDC39530f676362175afe35E96B4;
address public constant FOUNDER_GABA = 0xbe14e8d7a3417046627f305C918eC435C3c23fbC;
address public constant FOUNDER_LORDSLABS = 0xbb59f8ce665d238A9e8D942172D283ba87061F6F;
address public constant FOUNDER_CRAZYJUMP = 0xE386aE197A42e49C727BF15070FE71C68F18ad45;
// ======== CONSTRUCTOR ========
constructor() ERC721A("Mutant Shiba Club", "MSC") {}
/**
* @notice must be an EOA
*/
modifier callerIsUser() {
}
// ======== MINTING ========
/**
* @notice presale mint
*/
function preSaleMint(uint256 _quantity, uint256 _maxAmount, bytes32[] calldata _proof) external payable callerIsUser {
}
/**
* @notice community sale mint
*/
function communitySaleMint(bytes32[] calldata _proof) external payable callerIsUser {
}
/**
* @notice public sale mint
*/
function publicSaleMint(uint256 _quantity) external payable callerIsUser {
require(isPublicSaleActive, "PUBLIC SALE IS NOT ACTIVE");
require(totalSupply() + _quantity <= MAX_SUPPLY, "MAX SUPPLY REACHED" );
require(<FILL_ME>)
require(msg.value == publicSalePrice * _quantity, "NEED TO SEND CORRECT ETH AMOUNT");
publicSaleMinted[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function teamMint(uint256 _quantity, bool _founders) external payable onlyOwner {
}
// ======== SALE STATUS SETTERS ========
/**
* @notice activating or deactivating presale status
*/
function setPreSaleStatus(bool _status) external onlyOwner {
}
/**
* @notice activating or deactivating community sale status
*/
function setCommunitySaleStatus(bool _status) external onlyOwner {
}
/**
* @notice activating or deactivating public sale
*/
function setPublicSaleStatus(bool _status) external onlyOwner {
}
// ======== PRICE SETTERS ========
/**
* @notice set presale price
*/
function setPreSalePrice(uint256 _price) external onlyOwner {
}
/**
* @notice set whitelist price
*/
function setCommunitySalePrice(uint256 _price) external onlyOwner {
}
/**
* @notice set public sale price
*/
function setPublicSalePrice(uint256 _price) external onlyOwner {
}
// ======== MERKLE ROOT SETTERS ========
/**
* @notice set presale merkleroot
*/
function setPresaleMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
/**
* @notice set community sale merkleroot
*/
function setCommunitySaleMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
// ======== METADATA URI ========
/**
* @notice tokenURI
*/
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
}
/**
* @notice set base URI
*/
function setBaseURI(string calldata baseURI) external onlyOwner {
}
/**
* @notice set IsRevealed to true or false
*/
function setIsRevealed(bool _reveal) external onlyOwner {
}
/**
* @notice set startTokenId to 1
*/
function _startTokenId() internal view virtual override(ERC721A) returns (uint256) {
}
// ======== WITHDRAW GNOSIS ========
/**
* @notice withdraw funds to gnosis safe
*/
function withdraw() external onlyOwner {
}
}
| publicSaleMinted[msg.sender]+_quantity<=maxPublicSaleMint,"EXCEEDS MAX MINTS PER ADDRESS" | 508,141 | publicSaleMinted[msg.sender]+_quantity<=maxPublicSaleMint |
"maxSupply over." | // ERC1155γ§γγ»γΌγ«ζ©θ½γζγ€γ³γ³γγ©γ―γ
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract REREI is ERC1155Burnable, ERC2981, ReentrancyGuard, Ownable, DefaultOperatorFilterer {
string private _baseTokenURI;
mapping(uint256 => uint256) public maxSupply;
mapping(uint256 => uint256) public mintLimit;
mapping(uint256 => mapping(address => uint256)) public claimed;
mapping(uint256 => uint256) public price;
mapping(uint256 => bool) public saleStart;
mapping(uint256 => uint256) public totalSupply;
mapping(address => bool) public allowedAddress;
event Mint(uint256 tokenId, address walletAddress, uint256 quantity);
constructor() ERC1155("") {
}
function uri(uint256 _id) public view override returns (string memory) {
}
struct Role {
address payable roleAddress;
uint256 share; // 10000 = 100%
}
mapping(uint256 => Role[]) public tokenRoles;
function setRoles(uint256 _tokenId, address payable[] memory _roleAddresses, uint256[] memory _shares) public {
}
function getRoleSize(uint256 _tokenId) external view returns (uint256) {
}
// mint
function mint(uint256 _tokenId, uint256 _quantity, address _receiver) public payable nonReentrant {
require(
msg.value == price[_tokenId] * _quantity,
"Value sent does not meet price for NFT"
);
require(<FILL_ME>)
if (!allowedAddress[msg.sender]) {
require(
mintLimit[_tokenId] >= _quantity + claimed[_tokenId][msg.sender],
"mintLimit over."
);
}
_mint(_receiver, _tokenId, _quantity, "");
totalSupply[_tokenId] += _quantity;
claimed[_tokenId][msg.sender] += _quantity;
emit Mint(_tokenId, _receiver, _quantity);
// sendValue
uint256 balance = msg.value;
if (tokenRoles[_tokenId].length == 0) {
Address.sendValue(payable(owner()), balance);
} else {
for (uint256 i = 0; i < tokenRoles[_tokenId].length;) {
Address.sendValue(
tokenRoles[_tokenId][i].roleAddress,
(balance * tokenRoles[_tokenId][i].share) / 10000
);
unchecked {
i++;
}
}
}
}
function ownerMint(uint256 _tokenId, uint256 _quantity, address _receiver) public onlyOwner nonReentrant {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function setSaleStart(uint256 _tokenId, bool _state) external onlyOwner {
}
function setPrice(uint256 _tokenId, uint256 _price) external onlyOwner {
}
function setMintLimit(uint256 _tokenId, uint256 _amount) external onlyOwner {
}
function setMaxSupply(uint256 _tokenId, uint256 _amount) external onlyOwner {
}
function setAllowedAddress(address _address, bool _state) external onlyOwner {
}
// Burn
function burn(
address,
uint256 _tokenId,
uint256 _amount
) public override(ERC1155Burnable) onlyOwner {
}
function burnBatch(
address,
uint256[] memory _tokenIds,
uint256[] memory _amounts
) public override(ERC1155Burnable) onlyOwner {
}
// OpenSea OperatorFilterer
function setOperatorFilteringEnabled(bool _state) external onlyOwner {
}
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
// Royality
function setRoyalty(address _royaltyAddress, uint96 _feeNumerator)
external
onlyOwner
{
}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC1155, ERC2981)
returns (bool)
{
}
}
| maxSupply[_tokenId]>=totalSupply[_tokenId]+_quantity,"maxSupply over." | 508,158 | maxSupply[_tokenId]>=totalSupply[_tokenId]+_quantity |
"mintLimit over." | // ERC1155γ§γγ»γΌγ«ζ©θ½γζγ€γ³γ³γγ©γ―γ
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
contract REREI is ERC1155Burnable, ERC2981, ReentrancyGuard, Ownable, DefaultOperatorFilterer {
string private _baseTokenURI;
mapping(uint256 => uint256) public maxSupply;
mapping(uint256 => uint256) public mintLimit;
mapping(uint256 => mapping(address => uint256)) public claimed;
mapping(uint256 => uint256) public price;
mapping(uint256 => bool) public saleStart;
mapping(uint256 => uint256) public totalSupply;
mapping(address => bool) public allowedAddress;
event Mint(uint256 tokenId, address walletAddress, uint256 quantity);
constructor() ERC1155("") {
}
function uri(uint256 _id) public view override returns (string memory) {
}
struct Role {
address payable roleAddress;
uint256 share; // 10000 = 100%
}
mapping(uint256 => Role[]) public tokenRoles;
function setRoles(uint256 _tokenId, address payable[] memory _roleAddresses, uint256[] memory _shares) public {
}
function getRoleSize(uint256 _tokenId) external view returns (uint256) {
}
// mint
function mint(uint256 _tokenId, uint256 _quantity, address _receiver) public payable nonReentrant {
require(
msg.value == price[_tokenId] * _quantity,
"Value sent does not meet price for NFT"
);
require(
maxSupply[_tokenId] >= totalSupply[_tokenId] + _quantity,
"maxSupply over."
);
if (!allowedAddress[msg.sender]) {
require(<FILL_ME>)
}
_mint(_receiver, _tokenId, _quantity, "");
totalSupply[_tokenId] += _quantity;
claimed[_tokenId][msg.sender] += _quantity;
emit Mint(_tokenId, _receiver, _quantity);
// sendValue
uint256 balance = msg.value;
if (tokenRoles[_tokenId].length == 0) {
Address.sendValue(payable(owner()), balance);
} else {
for (uint256 i = 0; i < tokenRoles[_tokenId].length;) {
Address.sendValue(
tokenRoles[_tokenId][i].roleAddress,
(balance * tokenRoles[_tokenId][i].share) / 10000
);
unchecked {
i++;
}
}
}
}
function ownerMint(uint256 _tokenId, uint256 _quantity, address _receiver) public onlyOwner nonReentrant {
}
function setBaseURI(string memory _uri) external onlyOwner {
}
function setSaleStart(uint256 _tokenId, bool _state) external onlyOwner {
}
function setPrice(uint256 _tokenId, uint256 _price) external onlyOwner {
}
function setMintLimit(uint256 _tokenId, uint256 _amount) external onlyOwner {
}
function setMaxSupply(uint256 _tokenId, uint256 _amount) external onlyOwner {
}
function setAllowedAddress(address _address, bool _state) external onlyOwner {
}
// Burn
function burn(
address,
uint256 _tokenId,
uint256 _amount
) public override(ERC1155Burnable) onlyOwner {
}
function burnBatch(
address,
uint256[] memory _tokenIds,
uint256[] memory _amounts
) public override(ERC1155Burnable) onlyOwner {
}
// OpenSea OperatorFilterer
function setOperatorFilteringEnabled(bool _state) external onlyOwner {
}
function setApprovalForAll(address operator, bool approved)
public
override
onlyAllowedOperatorApproval(operator)
{
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
uint256 amount,
bytes memory data
) public override onlyAllowedOperator(from) {
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override onlyAllowedOperator(from) {
}
// Royality
function setRoyalty(address _royaltyAddress, uint96 _feeNumerator)
external
onlyOwner
{
}
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(ERC1155, ERC2981)
returns (bool)
{
}
}
| mintLimit[_tokenId]>=_quantity+claimed[_tokenId][msg.sender],"mintLimit over." | 508,158 | mintLimit[_tokenId]>=_quantity+claimed[_tokenId][msg.sender] |
"Already voted" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
import "./IERC20.sol";
import "./IERC20Metadata.sol";
import "./Ownable.sol";
enum PollType { PROPOSAL, EXECUTIVE, EVENT, PRIVATE }
enum VoteType { FOR, AGAINST }
enum PollStatus { PENDING, APPROVED, REJECTED, DRAW }
struct Poll {
PollType pollType;
uint64 pollDeadline;
uint64 pollStopped;
address pollOwner;
string pollInfo;
uint256 forWeight;
uint256 againstWeight;
}
struct Vote {
VoteType voteType;
uint256 voteWeight;
}
contract DusclopeGovernance is Context, IERC20, IERC20Metadata, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
// Poll-related state variables
Poll[] public polls;
mapping(uint256 => mapping(address => Vote)) public voted;
mapping(uint256 => mapping(address => bool)) public hasVoted;
event PollCreated(uint256 pollNum);
constructor(string memory name_, string memory symbol_, uint256 initialSupply) {
}
function name() public view override returns (string memory) {
}
function symbol() public view override returns (string memory) {
}
function decimals() public view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal {
}
function _mint(address account, uint256 amount) internal {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
// Poll-related functions
function createProposalPoll(uint64 _pollDeadline, string memory _pollInfo) external {
}
function createExecutivePoll(uint64 _pollDeadline, string memory _pollInfo) external onlyOwner {
}
function createEventPoll(uint64 _pollDeadline, string memory _pollInfo) external onlyOwner {
}
function _createPoll(PollType _pollType, uint64 _pollDeadline, string memory _pollInfo) private returns (uint256) {
}
function vote(uint256 pollNum, VoteType voteType, uint256 voteWeight) external {
require(pollNum < polls.length, "Invalid poll number");
require(<FILL_ME>)
Poll storage poll = polls[pollNum];
require(block.timestamp < poll.pollDeadline, "Poll is closed");
voted[pollNum][_msgSender()] = Vote(voteType, voteWeight);
hasVoted[pollNum][_msgSender()] = true;
if (voteType == VoteType.FOR) {
poll.forWeight += voteWeight;
} else {
poll.againstWeight += voteWeight;
}
}
function getPollStatus(uint256 pollNum) public view returns (PollStatus) {
}
function closePoll(uint256 pollNum) external onlyOwner {
}
}
| !hasVoted[pollNum][_msgSender()],"Already voted" | 508,183 | !hasVoted[pollNum][_msgSender()] |
"ERC721Metadata: URI query for nonexistent token" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
//require(ownerOf(fromTokenId) == msg.sender,"not owner");
require(<FILL_ME>)
require(tokenApproved[ownerOf(fromTokenId)][msg.sender] == fromTokenId,"not approve");
require(tokenIdBalance[toTokenId] >= amount,"not enought token in balance");
tokenIdBalance[fromTokenId] -= amount;
tokenIdBalance[toTokenId] += amount;
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| _exists(toTokenId),"ERC721Metadata: URI query for nonexistent token" | 508,229 | _exists(toTokenId) |
"not approve" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
//require(ownerOf(fromTokenId) == msg.sender,"not owner");
require(_exists(toTokenId), "ERC721Metadata: URI query for nonexistent token");
require(<FILL_ME>)
require(tokenIdBalance[toTokenId] >= amount,"not enought token in balance");
tokenIdBalance[fromTokenId] -= amount;
tokenIdBalance[toTokenId] += amount;
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| tokenApproved[ownerOf(fromTokenId)][msg.sender]==fromTokenId,"not approve" | 508,229 | tokenApproved[ownerOf(fromTokenId)][msg.sender]==fromTokenId |
"not enought token in balance" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
//require(ownerOf(fromTokenId) == msg.sender,"not owner");
require(_exists(toTokenId), "ERC721Metadata: URI query for nonexistent token");
require(tokenApproved[ownerOf(fromTokenId)][msg.sender] == fromTokenId,"not approve");
require(<FILL_ME>)
tokenIdBalance[fromTokenId] -= amount;
tokenIdBalance[toTokenId] += amount;
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| tokenIdBalance[toTokenId]>=amount,"not enought token in balance" | 508,229 | tokenIdBalance[toTokenId]>=amount |
"not approve" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
require(_exists(toTokenId), "ERC721Metadata: URI query for nonexistent token");
//require(ownerOf(fromTokenId) == msg.sender,"not owner");
require(<FILL_ME>)
require(tokenIdBalance[toTokenId] >= amount,"not enought token in balance");
tokenApprovedByallowanc[ownerOf(fromTokenId)][msg.sender][fromTokenId] -= amount;
tokenIdBalance[fromTokenId] -= amount;
tokenIdBalance[toTokenId] += amount;
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| tokenApprovedByallowanc[ownerOf(fromTokenId)][msg.sender][fromTokenId]>0,"not approve" | 508,229 | tokenApprovedByallowanc[ownerOf(fromTokenId)][msg.sender][fromTokenId]>0 |
"not owner" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
require(_exists(toTokenId), "ERC721Metadata: URI query for nonexistent token");
require(<FILL_ME>)
require(tokenIdBalance[toTokenId] >= amount,"not enought token in balance");
tokenIdBalance[fromTokenId] -= amount;
tokenIdBalance[toTokenId] += amount;
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| ownerOf(fromTokenId)==msg.sender,"not owner" | 508,229 | ownerOf(fromTokenId)==msg.sender |
"exceed max quilidity amount" | pragma solidity ^0.8;
contract ethv is ERC721, ERC721Enumerable,Ownable {
Idata data;
uint256 private _nextTokenId;
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIds;
string description;
mapping(uint256 => uint256) public tokenIdBalance;
mapping(address => mapping(address => uint)) public tokenApproved;//owner spender tokenid
mapping (address => mapping (address =>mapping (uint => uint)))public tokenApprovedByallowanc;//owner spender tokenid amount
mapping (address => uint) public userMintedAmount;
//uint No;
uint public MAX_PER_MINT;
uint public inscription_token_amount;
uint public MAX_LIQUIDITY_AMOUNT;
uint public MINTED_LIQUIDITY_AMOUNT;
uint public MAX_SUPPLY;
uint public MAX_PERMINT_AMOUNT;
fallback() external payable {
}
receive() external payable {
}
constructor(string memory _name, string memory _description,uint _maxTotalSupply,uint _maxPermint_Amount,uint _max_per_mint)
ERC721(_name, "INSCRIPTION")
{
}
function setData(address _data) public onlyOwner {
}
function approvedByallowanc(address spender,uint tokenId,uint amount) public {
}
function approveTokenIdToken(uint tokenId,address spender) public {
}
function revokeApproveTokenIdToken(uint tokenId,address spender) public {
}
function transferFromBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferFromBalanceAmountByAllowance(uint fromTokenId,uint toTokenId,uint amount) public{
}
function transferBalanceAmount(uint fromTokenId,uint toTokenId,uint amount) public{
}
function addBalanceToTokenId(uint tokenId,uint amount) public onlyOwner {
require(<FILL_ME>)
MINTED_LIQUIDITY_AMOUNT += amount;
tokenIdBalance[tokenId] += amount;
MAX_SUPPLY += amount;
inscription_token_amount;
}
// The following functions are overrides required by Solidity.
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
function addrToString(address addr) public pure returns (string memory) {
}
function getLevels(uint256 tokenId) public view returns (string memory) {
}
function getLevels_Num(uint256 tokenId) public view returns (uint) {
}
function tokenURI(uint256 tokenId) public override view returns (string memory){
}
function inscribe(uint _amount) public {
}
function inscribeForInternal(uint _amount) internal {
}
function inscribeForInternal2(uint _amount) internal {
}
function merge(uint [] memory _tokenIdArr) public {
}
function seperate(uint _tokenId,uint [] memory _amountArr) public {
}
function burn(uint _tokenId) public {
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
}
| amount+MINTED_LIQUIDITY_AMOUNT<=MAX_LIQUIDITY_AMOUNT,"exceed max quilidity amount" | 508,229 | amount+MINTED_LIQUIDITY_AMOUNT<=MAX_LIQUIDITY_AMOUNT |