comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"SALE_HAS_BEGUN" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/draft-ERC721Votes.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./RandomlyAssigned.sol";
/**
* @title The Connectors Contract
*/
contract TheConnectors is ERC721, ERC721Enumerable, EIP712, ERC721Votes, Ownable, ReentrancyGuard, RandomlyAssigned {
using ECDSA for bytes32;
uint8 constant MAX_MINTS_PER_WALLET = 20;
uint16 constant MAX_SUPPLY = 10000;
// Final price - 0.1 ETH
uint256 constant FINAL_PRICE = 100000000000000000;
// Used to validate whitelist mint addresses
address private signerAddress = 0xd19A6eC87f54B13455089d7C1115f73561508f40;
string public constant PROVENANCE = "cc91c82c1587adde49e77ed934fc6e10991fa84c67cf8a003ce23d0bd0292125";
// Remember the number of mints per wallet to control max mints value
mapping (address => uint8) public totalMintsPerAddress;
string private baseURI;
// Public vars
bool public saleActive;
bool public presaleActive;
modifier whenSaleActive()
{
}
modifier whenPreSaleActive()
{
}
constructor(string memory _baseTokenURI, string memory name, string memory symbol)
ERC721(name, symbol)
EIP712(name, "1")
RandomlyAssigned(MAX_SUPPLY, 0)
{
}
/**
* @notice Contract might receive/hold ETH as part of the maintenance process.
*/
receive() external payable {}
/**
* @notice Change signer address
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @notice Start public sale
*/
function startPublicSale() external onlyOwner
{
require(<FILL_ME>)
saleActive = true;
}
/**
* @notice Start presale
*/
function startPresale() external onlyOwner
{
}
/**
* @notice Pause public sale
*/
function pausePublicSale() external onlyOwner
{
}
/**
* @notice Pause presale
*/
function pausePresale() external onlyOwner
{
}
/**
* @notice Allow withdrawing funds
*/
function withdraw() external onlyOwner {
}
/**
* @notice Public sale. Mint connectors
*/
function mintPublicConnectors(uint8 numConnectors) external payable whenSaleActive nonReentrant
{
}
/**
* @notice Presale. Mint connectors
*/
function mintPresaleConnectors(uint8 numConnectors, bytes memory signature) external payable whenPreSaleActive nonReentrant
{
}
/**
* @notice Verify signature
*/
function verifyAddressSigner(bytes memory signature) private view returns (bool) {
}
/**
* @notice Read the base token URI
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @notice Add json extension to all token URI's
*/
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Votes)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| !saleActive,"SALE_HAS_BEGUN" | 493,205 | !saleActive |
"MAX_SUPPLY_ERROR" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/draft-ERC721Votes.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./RandomlyAssigned.sol";
/**
* @title The Connectors Contract
*/
contract TheConnectors is ERC721, ERC721Enumerable, EIP712, ERC721Votes, Ownable, ReentrancyGuard, RandomlyAssigned {
using ECDSA for bytes32;
uint8 constant MAX_MINTS_PER_WALLET = 20;
uint16 constant MAX_SUPPLY = 10000;
// Final price - 0.1 ETH
uint256 constant FINAL_PRICE = 100000000000000000;
// Used to validate whitelist mint addresses
address private signerAddress = 0xd19A6eC87f54B13455089d7C1115f73561508f40;
string public constant PROVENANCE = "cc91c82c1587adde49e77ed934fc6e10991fa84c67cf8a003ce23d0bd0292125";
// Remember the number of mints per wallet to control max mints value
mapping (address => uint8) public totalMintsPerAddress;
string private baseURI;
// Public vars
bool public saleActive;
bool public presaleActive;
modifier whenSaleActive()
{
}
modifier whenPreSaleActive()
{
}
constructor(string memory _baseTokenURI, string memory name, string memory symbol)
ERC721(name, symbol)
EIP712(name, "1")
RandomlyAssigned(MAX_SUPPLY, 0)
{
}
/**
* @notice Contract might receive/hold ETH as part of the maintenance process.
*/
receive() external payable {}
/**
* @notice Change signer address
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @notice Start public sale
*/
function startPublicSale() external onlyOwner
{
}
/**
* @notice Start presale
*/
function startPresale() external onlyOwner
{
}
/**
* @notice Pause public sale
*/
function pausePublicSale() external onlyOwner
{
}
/**
* @notice Pause presale
*/
function pausePresale() external onlyOwner
{
}
/**
* @notice Allow withdrawing funds
*/
function withdraw() external onlyOwner {
}
/**
* @notice Public sale. Mint connectors
*/
function mintPublicConnectors(uint8 numConnectors) external payable whenSaleActive nonReentrant
{
require(<FILL_ME>)
require(
totalMintsPerAddress[msg.sender] + numConnectors <= MAX_MINTS_PER_WALLET,
"MAX_MINTS_PER_WALLET_ERROR"
);
uint256 costToMint = FINAL_PRICE * numConnectors;
require(costToMint <= msg.value, "INVALID_PRICE");
totalMintsPerAddress[msg.sender] += numConnectors;
for (uint256 i = 0; i < numConnectors; i++) {
uint256 mintIndex = nextToken();
_safeMint(msg.sender, mintIndex);
}
if (msg.value > costToMint) {
Address.sendValue(payable(msg.sender), msg.value - costToMint);
}
}
/**
* @notice Presale. Mint connectors
*/
function mintPresaleConnectors(uint8 numConnectors, bytes memory signature) external payable whenPreSaleActive nonReentrant
{
}
/**
* @notice Verify signature
*/
function verifyAddressSigner(bytes memory signature) private view returns (bool) {
}
/**
* @notice Read the base token URI
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @notice Add json extension to all token URI's
*/
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Votes)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| totalSupply()+numConnectors<=MAX_SUPPLY,"MAX_SUPPLY_ERROR" | 493,205 | totalSupply()+numConnectors<=MAX_SUPPLY |
"MAX_MINTS_PER_WALLET_ERROR" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/draft-ERC721Votes.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./RandomlyAssigned.sol";
/**
* @title The Connectors Contract
*/
contract TheConnectors is ERC721, ERC721Enumerable, EIP712, ERC721Votes, Ownable, ReentrancyGuard, RandomlyAssigned {
using ECDSA for bytes32;
uint8 constant MAX_MINTS_PER_WALLET = 20;
uint16 constant MAX_SUPPLY = 10000;
// Final price - 0.1 ETH
uint256 constant FINAL_PRICE = 100000000000000000;
// Used to validate whitelist mint addresses
address private signerAddress = 0xd19A6eC87f54B13455089d7C1115f73561508f40;
string public constant PROVENANCE = "cc91c82c1587adde49e77ed934fc6e10991fa84c67cf8a003ce23d0bd0292125";
// Remember the number of mints per wallet to control max mints value
mapping (address => uint8) public totalMintsPerAddress;
string private baseURI;
// Public vars
bool public saleActive;
bool public presaleActive;
modifier whenSaleActive()
{
}
modifier whenPreSaleActive()
{
}
constructor(string memory _baseTokenURI, string memory name, string memory symbol)
ERC721(name, symbol)
EIP712(name, "1")
RandomlyAssigned(MAX_SUPPLY, 0)
{
}
/**
* @notice Contract might receive/hold ETH as part of the maintenance process.
*/
receive() external payable {}
/**
* @notice Change signer address
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @notice Start public sale
*/
function startPublicSale() external onlyOwner
{
}
/**
* @notice Start presale
*/
function startPresale() external onlyOwner
{
}
/**
* @notice Pause public sale
*/
function pausePublicSale() external onlyOwner
{
}
/**
* @notice Pause presale
*/
function pausePresale() external onlyOwner
{
}
/**
* @notice Allow withdrawing funds
*/
function withdraw() external onlyOwner {
}
/**
* @notice Public sale. Mint connectors
*/
function mintPublicConnectors(uint8 numConnectors) external payable whenSaleActive nonReentrant
{
require(
totalSupply() + numConnectors <= MAX_SUPPLY,
"MAX_SUPPLY_ERROR"
);
require(<FILL_ME>)
uint256 costToMint = FINAL_PRICE * numConnectors;
require(costToMint <= msg.value, "INVALID_PRICE");
totalMintsPerAddress[msg.sender] += numConnectors;
for (uint256 i = 0; i < numConnectors; i++) {
uint256 mintIndex = nextToken();
_safeMint(msg.sender, mintIndex);
}
if (msg.value > costToMint) {
Address.sendValue(payable(msg.sender), msg.value - costToMint);
}
}
/**
* @notice Presale. Mint connectors
*/
function mintPresaleConnectors(uint8 numConnectors, bytes memory signature) external payable whenPreSaleActive nonReentrant
{
}
/**
* @notice Verify signature
*/
function verifyAddressSigner(bytes memory signature) private view returns (bool) {
}
/**
* @notice Read the base token URI
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @notice Add json extension to all token URI's
*/
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Votes)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| totalMintsPerAddress[msg.sender]+numConnectors<=MAX_MINTS_PER_WALLET,"MAX_MINTS_PER_WALLET_ERROR" | 493,205 | totalMintsPerAddress[msg.sender]+numConnectors<=MAX_MINTS_PER_WALLET |
"SIGNATURE_VALIDATION_FAILED" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/draft-ERC721Votes.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "./RandomlyAssigned.sol";
/**
* @title The Connectors Contract
*/
contract TheConnectors is ERC721, ERC721Enumerable, EIP712, ERC721Votes, Ownable, ReentrancyGuard, RandomlyAssigned {
using ECDSA for bytes32;
uint8 constant MAX_MINTS_PER_WALLET = 20;
uint16 constant MAX_SUPPLY = 10000;
// Final price - 0.1 ETH
uint256 constant FINAL_PRICE = 100000000000000000;
// Used to validate whitelist mint addresses
address private signerAddress = 0xd19A6eC87f54B13455089d7C1115f73561508f40;
string public constant PROVENANCE = "cc91c82c1587adde49e77ed934fc6e10991fa84c67cf8a003ce23d0bd0292125";
// Remember the number of mints per wallet to control max mints value
mapping (address => uint8) public totalMintsPerAddress;
string private baseURI;
// Public vars
bool public saleActive;
bool public presaleActive;
modifier whenSaleActive()
{
}
modifier whenPreSaleActive()
{
}
constructor(string memory _baseTokenURI, string memory name, string memory symbol)
ERC721(name, symbol)
EIP712(name, "1")
RandomlyAssigned(MAX_SUPPLY, 0)
{
}
/**
* @notice Contract might receive/hold ETH as part of the maintenance process.
*/
receive() external payable {}
/**
* @notice Change signer address
*/
function setSignerAddress(address _signerAddress) external onlyOwner {
}
/**
* @notice Start public sale
*/
function startPublicSale() external onlyOwner
{
}
/**
* @notice Start presale
*/
function startPresale() external onlyOwner
{
}
/**
* @notice Pause public sale
*/
function pausePublicSale() external onlyOwner
{
}
/**
* @notice Pause presale
*/
function pausePresale() external onlyOwner
{
}
/**
* @notice Allow withdrawing funds
*/
function withdraw() external onlyOwner {
}
/**
* @notice Public sale. Mint connectors
*/
function mintPublicConnectors(uint8 numConnectors) external payable whenSaleActive nonReentrant
{
}
/**
* @notice Presale. Mint connectors
*/
function mintPresaleConnectors(uint8 numConnectors, bytes memory signature) external payable whenPreSaleActive nonReentrant
{
require(
totalSupply() + numConnectors <= MAX_SUPPLY,
"MAX_SUPPLY_ERROR"
);
require(
totalMintsPerAddress[msg.sender] + numConnectors <= MAX_MINTS_PER_WALLET,
"MAX_MINTS_PER_WALLET_ERROR"
);
require(<FILL_ME>)
uint256 costToMint = FINAL_PRICE * numConnectors;
require(costToMint <= msg.value, "INVALID_PRICE");
totalMintsPerAddress[msg.sender] += numConnectors;
for (uint256 i = 0; i < numConnectors; i++) {
uint256 mintIndex = nextToken();
_safeMint(msg.sender, mintIndex);
}
if (msg.value > costToMint) {
Address.sendValue(payable(msg.sender), msg.value - costToMint);
}
}
/**
* @notice Verify signature
*/
function verifyAddressSigner(bytes memory signature) private view returns (bool) {
}
/**
* @notice Read the base token URI
*/
function _baseURI() internal view override returns (string memory) {
}
/**
* @notice Update the base token URI
*/
function setBaseURI(string memory uri) external onlyOwner {
}
/**
* @notice Add json extension to all token URI's
*/
function tokenURI(uint256 tokenId) public view override returns (string memory)
{
}
function _beforeTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Enumerable)
{
}
function _afterTokenTransfer(address from, address to, uint256 tokenId)
internal
override(ERC721, ERC721Votes)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable)
returns (bool)
{
}
}
| verifyAddressSigner(signature),"SIGNATURE_VALIDATION_FAILED" | 493,205 | verifyAddressSigner(signature) |
"Error: Level 1(+) admin clearance required." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
require(<FILL_ME>)
_;
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| accounts[msg.sender].isAdmin>0,"Error: Level 1(+) admin clearance required." | 493,261 | accounts[msg.sender].isAdmin>0 |
"Error: Level 2(+) admin clearance required." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
require(<FILL_ME>)
_;
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| accounts[msg.sender].isAdmin>1,"Error: Level 2(+) admin clearance required." | 493,261 | accounts[msg.sender].isAdmin>1 |
"Error: No re-entrancy." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
require(<FILL_ME>)
MINTLOCK = true;
_;
MINTLOCK = false;
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| !MINTLOCK,"Error: No re-entrancy." | 493,261 | !MINTLOCK |
"Error: This would make reserved less than 0." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
require(<FILL_ME>)
require(accounts[_addr].nftsReserved - _decreaseReservedBy >= 0, "Error: User does not have this many reserved NFTs.");
RESERVEDNFTS -= _decreaseReservedBy;
accounts[_addr].nftsReserved -= _decreaseReservedBy;
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| RESERVEDNFTS-_decreaseReservedBy>=0,"Error: This would make reserved less than 0." | 493,261 | RESERVEDNFTS-_decreaseReservedBy>=0 |
"Error: User does not have this many reserved NFTs." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
require(RESERVEDNFTS - _decreaseReservedBy >= 0, "Error: This would make reserved less than 0.");
require(<FILL_ME>)
RESERVEDNFTS -= _decreaseReservedBy;
accounts[_addr].nftsReserved -= _decreaseReservedBy;
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| accounts[_addr].nftsReserved-_decreaseReservedBy>=0,"Error: User does not have this many reserved NFTs." | 493,261 | accounts[_addr].nftsReserved-_decreaseReservedBy>=0 |
"Error: This would exceed the max supply." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
require(<FILL_ME>)
RESERVEDNFTS += _increaseReservedBy;
accounts[_addr].nftsReserved += _increaseReservedBy;
if ( accounts[_addr].isAdmin == 0 ) { accounts[_addr].isAdmin ++; }
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| RESERVEDNFTS+totalSupply()+_increaseReservedBy<=MAXSUPPLY,"Error: This would exceed the max supply." | 493,261 | RESERVEDNFTS+totalSupply()+_increaseReservedBy<=MAXSUPPLY |
"Error: You would exceed the airdrop limit." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
require(<FILL_ME>)
for (uint i = 0; i < _addr.length; i++) {
_safeMint(_addr[i], 1);
emit Mint(msg.sender, totalSupply());
}
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| totalSupply()+_addr.length<=(MAXSUPPLY-RESERVEDNFTS),"Error: You would exceed the airdrop limit." | 493,261 | totalSupply()+_addr.length<=(MAXSUPPLY-RESERVEDNFTS) |
"Error: You are trying to claim more NFTs than you have reserved." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
require(_amount > 0, "Error: Need to have reserved supply.");
require(<FILL_ME>)
require(totalSupply() + _amount <= MAXSUPPLY, "Error: You would exceed the max supply limit.");
accounts[msg.sender].nftsReserved -= _amount;
RESERVEDNFTS -= _amount;
_safeMint(msg.sender, _amount);
emit Mint(msg.sender, totalSupply());
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| accounts[msg.sender].nftsReserved>=_amount,"Error: You are trying to claim more NFTs than you have reserved." | 493,261 | accounts[msg.sender].nftsReserved>=_amount |
"Error: You would exceed the max supply limit." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
require(_amount > 0, "Error: Need to have reserved supply.");
require(accounts[msg.sender].nftsReserved >= _amount, "Error: You are trying to claim more NFTs than you have reserved.");
require(<FILL_ME>)
accounts[msg.sender].nftsReserved -= _amount;
RESERVEDNFTS -= _amount;
_safeMint(msg.sender, _amount);
emit Mint(msg.sender, totalSupply());
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| totalSupply()+_amount<=MAXSUPPLY,"Error: You would exceed the max supply limit." | 493,261 | totalSupply()+_amount<=MAXSUPPLY |
"Error: Purchase would exceed max supply." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
require(whitelistMintEnabled, 'The whitelist sale is not enabled!');
require(<FILL_ME>)
require((_mintAmount + accounts[msg.sender].mintedNFTs) <= WALLETLIMIT, "Error: You would exceed the wallet limit.");
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Sneaky! You are not on the whitelist');
accounts[msg.sender].mintedNFTs += _mintAmount;
_safeMint(_msgSender(), _mintAmount);
emit Mint(msg.sender, totalSupply());
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| totalSupply()+_mintAmount<=(MAXSUPPLY-RESERVEDNFTS),"Error: Purchase would exceed max supply." | 493,261 | totalSupply()+_mintAmount<=(MAXSUPPLY-RESERVEDNFTS) |
"Error: You would exceed the wallet limit." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
require(whitelistMintEnabled, 'The whitelist sale is not enabled!');
require(totalSupply() + _mintAmount <= (MAXSUPPLY - RESERVEDNFTS), "Error: Purchase would exceed max supply.");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Sneaky! You are not on the whitelist');
accounts[msg.sender].mintedNFTs += _mintAmount;
_safeMint(_msgSender(), _mintAmount);
emit Mint(msg.sender, totalSupply());
}
function publicMint(uint _amount) external payable noReentrant {
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| (_mintAmount+accounts[msg.sender].mintedNFTs)<=WALLETLIMIT,"Error: You would exceed the wallet limit." | 493,261 | (_mintAmount+accounts[msg.sender].mintedNFTs)<=WALLETLIMIT |
"Error: Purchase would exceed max supply." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
require(SALEISLIVE, "Error: Sale is not active.");
require(<FILL_ME>)
require((_amount + accounts[msg.sender].mintedNFTs) <= WALLETLIMIT, "Error: You would exceed the wallet limit.");
require(!isContract(msg.sender), "Error: Contracts cannot mint.");
require(msg.value >= (THEMINTPRICE * _amount), "Error: Not enough ETH sent.");
accounts[msg.sender].mintedNFTs += _amount;
_safeMint(msg.sender, _amount);
emit Mint(msg.sender, totalSupply());
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| totalSupply()+_amount<=(MAXSUPPLY-RESERVEDNFTS),"Error: Purchase would exceed max supply." | 493,261 | totalSupply()+_amount<=(MAXSUPPLY-RESERVEDNFTS) |
"Error: You would exceed the wallet limit." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
require(SALEISLIVE, "Error: Sale is not active.");
require(totalSupply() + _amount <= (MAXSUPPLY - RESERVEDNFTS), "Error: Purchase would exceed max supply.");
require(<FILL_ME>)
require(!isContract(msg.sender), "Error: Contracts cannot mint.");
require(msg.value >= (THEMINTPRICE * _amount), "Error: Not enough ETH sent.");
accounts[msg.sender].mintedNFTs += _amount;
_safeMint(msg.sender, _amount);
emit Mint(msg.sender, totalSupply());
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| (_amount+accounts[msg.sender].mintedNFTs)<=WALLETLIMIT,"Error: You would exceed the wallet limit." | 493,261 | (_amount+accounts[msg.sender].mintedNFTs)<=WALLETLIMIT |
"Error: Not enough ETH sent." | // SPDX-License-Identifier: MIT
/*
▄▄ ▄▄ ▄▄ ▄▄
███▀▀██▀▀█████ ▀████▀ ██ ██ ██ ▀███ ▀████▀ ▀███▀ ██
█▀ ██ ▀███ ██ ██ ██ ██ ██ ▄█▀
██ ███████▄ ▄▄█▀██ ██ ▀███ ████████████ ██ ▄▄█▀██ ██ ▄█▀ ▀███ ▀████████▄ ▄█▀█████▄██▀███
▓█ ██ ██ ▄█▀ ██ ██ ██ ██ ██ ▓█ ▄█▀ ██ █████▄ ██ ██ ██ ▄██ ██ ██ ▀▀
▓█ ██ █▓ ▓█▀▀▀▀▀▀ █▓ ▄ ▓█ ██ ██ ▓█ ▓█▀▀▀▀▀▀ ▓█ ██▓ ▓█ █▓ ██ ▀▓▓███▀ ▀█████▄
▓█ █▓ █▓ ▓█▄ ▄ █▓ ▒█ ▓█ █▓ █▓ ▓█ ▓█▄ ▄ ▓█ ▀▓▓▄ ▓█ █▓ ▓█ █▓ ██
▓█ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓ ▓▓ ▓▓ ▓▓ ▓▓ ▓▓▀▀▀▀▀▀ ▓▓ ▓▒▓ ▓▓ ▓▓ ▓▓ ▀▓▓▓▓▓▀ ▀▓ █▓
▓▓ ▓▒ ▓▒ ▒▓▓ ▓▒ ▓▓ ▓▓ ▓▓ ▓▓ ▒▓ ▒▓▓ ▓▓ ▒▓▓▓ ▓▓ ▓▓ ▓▓ ▓▒ ▓▓ ▓▓
▒ ▒▓▒▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▓▒ ▒▒ ▒ ▒ ▒▒▒ ▒ ▒▒▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒ ▒ ▒ ▒▒ ▒ ▒▒ ▒▒▒ ▒▓▒ ▒▒ ▒▓▒ ▒ ▒ ▒▓▒
▒▒ ▒▒
▒▒▒▒ ▒▒
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';
import 'erc721a/contracts/extensions/ERC721AQueryable.sol';
import 'hardhat/console.sol';
contract TheLittleKings is Ownable, ERC721AQueryable, PaymentSplitter {
uint public MAXSUPPLY = 4444;
uint public THEMINTPRICE = 0 ether;
uint public WALLETLIMIT = 2;
string private METADATAURI;
string private CONTRACTURI;
bool public SALEISLIVE = false;
bool private MINTLOCK;
uint public RESERVEDNFTS;
uint public id = totalSupply();
string public hiddenMetadataUri;
bool public revealed = false;
bool public whitelistMintEnabled = false;
bool public preMintEnabled = false;
struct Account {
uint nftsReserved;
uint mintedNFTs;
uint isAdmin;
}
mapping(address => Account) public accounts;
event Mint(address indexed sender, uint totalSupply);
event PermanentURI(string _value, uint256 indexed _id);
event Burn(address indexed sender, uint indexed _id);
address[] private _distro;
uint[] private _distro_shares;
bytes32 public merkleRoot;
constructor(
address[] memory distro,
uint[] memory distro_shares,
bytes32 _merkleRoot,
string memory _metadata
)
ERC721A("THE LITTLE KINGS", "KING")
PaymentSplitter(distro, distro_shares)
{
}
// ==== Modifiers =====
modifier minAdmin1() {
}
modifier minAdmin2() {
}
modifier noReentrant() {
}
// ==== Overrides ====
// Start token IDs at 1 instead of 0
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
// ==== Setters ====
function adminLevelRaise(address _addr) external onlyOwner {
}
function adminLevelLower(address _addr) external onlyOwner {
}
function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function reservesDecrease(uint _decreaseReservedBy, address _addr) external onlyOwner {
}
function reservesIncrease(uint _increaseReservedBy, address _addr) external onlyOwner {
}
function salePublicActivate() external minAdmin2 {
}
function setWhiteListEnabled() external minAdmin2 {
}
function setPreMintEnabled() external minAdmin2 {
}
function salePublicDeactivate() external minAdmin2 {
}
function setBaseURI(string memory _newURI) external minAdmin2 {
}
function setContractURI(string memory _newURI) external onlyOwner {
}
function setMaxSupply(uint _maxSupply) external onlyOwner {
}
function setMintPrice(uint _newPrice) external onlyOwner {
}
function setWalletLimit(uint _newLimit) external onlyOwner {
}
// ==== Getters ====
function getTotalSupply() public view returns (uint) {
}
// -- For OpenSea
function contractURI() public view returns (string memory) {
}
// -- For Metadata
function _baseURI() internal view virtual override returns (string memory) {
}
// -- For Convenience
function getMintPrice() public view returns (uint){
}
// === Functions ====
function airDropNFT(address[] memory _addr) external minAdmin2 {
}
function claimReserved(uint _amount) external minAdmin1 {
}
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable {
}
function publicMint(uint _amount) external payable noReentrant {
require(SALEISLIVE, "Error: Sale is not active.");
require(totalSupply() + _amount <= (MAXSUPPLY - RESERVEDNFTS), "Error: Purchase would exceed max supply.");
require((_amount + accounts[msg.sender].mintedNFTs) <= WALLETLIMIT, "Error: You would exceed the wallet limit.");
require(!isContract(msg.sender), "Error: Contracts cannot mint.");
require(<FILL_ME>)
accounts[msg.sender].mintedNFTs += _amount;
_safeMint(msg.sender, _amount);
emit Mint(msg.sender, totalSupply());
}
function burn(uint _id) external returns (bool, uint) {
}
function cashOut() external minAdmin2 {
}
function isContract(address account) internal view returns (bool) {
}
}
| msg.value>=(THEMINTPRICE*_amount),"Error: Not enough ETH sent." | 493,261 | msg.value>=(THEMINTPRICE*_amount) |
"Invalid merkle proof" | //
//
//
////////////////////////////////////////////////////////////////////////////////
// //
// ██████ ███████ ████████ ██████ ███████ ███████ ██ ██████ ██████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ███ █████ ██ ██████ █████ █████ ██ █████ █████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██████ ███████ ██ ██ ██ ███████ ███████ ███████ ██████ ██████ //
// //
////////////////////////////////////////////////////////////////////////////////
//
//
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/presets/ERC1155PresetMinterPauser.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract JIGGIES33Minter is Ownable {
address public jIGGIES33Address = 0x476Ae7237d50E01C84d8f04E7C8021909600A898;
bytes32 public genesisClaimRoot = 0x232450d8a4fb5d9e42138c429c6be5b0a6154662cb284556acb6c8b6f26c9545;
bytes32 public genesisMintRoot = 0x232450d8a4fb5d9e42138c429c6be5b0a6154662cb284556acb6c8b6f26c9545;
uint256 public genesisHolderPrice = 0.45 ether;
uint256 public publicPrice = 0.57 ether;
bool public isGenesisMintClaimEnabled = false;
bool public isPublicMintEnabled = true;
mapping(address => uint256) public claimedNFTs;
mapping(address => uint256) public mintedNFTs;
uint256 public _idTracker = 118;
uint256 public maxSupply = 1000;
function setclaimRoot(bytes32 newroot) public onlyOwner { }
function setMintRoot(bytes32 newroot) public onlyOwner { }
function setConfig(uint256 _genesisHolderPrice,
uint256 _publicPrice,
bool _isGenesisMintClaimEnabled,
bool _isPublicMintEnabled,
bytes32 _claimRoot,
bytes32 _mintRoot,
uint256 _maxSupply)
public
onlyOwner
{
}
function getAvailableSupply() public view returns (uint256) {
}
function setSupply(uint256 _maxSupply)
public
onlyOwner
{
}
function setIsGenesisMintClaimEnabled(bool isEnabled) public onlyOwner {
}
function setIsPublicMintEnabled(bool isEnabled) public onlyOwner {
}
function getPublicPrice() public view returns (uint256) {
}
function setPublicPrice(uint256 _price)
public
onlyOwner
{
}
function getGenesisHolderPrice() public view returns (uint256) {
}
function setGenesisHolderPrice(uint256 _price)
public
onlyOwner
{
}
function setJIGGIES33Address(address _address) public onlyOwner {
}
function airdrop(
address[] memory to,
uint256[] memory id,
uint256[] memory amount
) onlyOwner public {
}
function setIdTracker(uint256 id) public onlyOwner {
}
function claimGenesisHolder(uint256 amount, uint256 balance, bytes32[] calldata proof) public {
require(isGenesisMintClaimEnabled, "Mint not enabled");
require(_idTracker <= maxSupply, "Not enough supply");
require(<FILL_ME>)
require(amount > 0, "Amount must be greater than 0");
require(claimedNFTs[msg.sender] + amount <= balance * 3, "Wallet already claimed");
ERC1155PresetMinterPauser token = ERC1155PresetMinterPauser(jIGGIES33Address);
for(uint256 i = 0; i < amount; i++){
token.mint(msg.sender, _idTracker, 1, "");
_idTracker += 1;
}
claimedNFTs[msg.sender] += amount;
}
function mintGenesisHolder(uint256 amount, uint256 balance, bytes32[] calldata proof) public payable {
}
function mintPublic(uint256 amount) public payable {
}
function withdraw() public onlyOwner {
}
}
| MerkleProof.verify(proof,genesisClaimRoot,keccak256(abi.encodePacked(msg.sender,balance))),"Invalid merkle proof" | 493,394 | MerkleProof.verify(proof,genesisClaimRoot,keccak256(abi.encodePacked(msg.sender,balance))) |
"Wallet already claimed" | //
//
//
////////////////////////////////////////////////////////////////////////////////
// //
// ██████ ███████ ████████ ██████ ███████ ███████ ██ ██████ ██████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ███ █████ ██ ██████ █████ █████ ██ █████ █████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██████ ███████ ██ ██ ██ ███████ ███████ ███████ ██████ ██████ //
// //
////////////////////////////////////////////////////////////////////////////////
//
//
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/presets/ERC1155PresetMinterPauser.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract JIGGIES33Minter is Ownable {
address public jIGGIES33Address = 0x476Ae7237d50E01C84d8f04E7C8021909600A898;
bytes32 public genesisClaimRoot = 0x232450d8a4fb5d9e42138c429c6be5b0a6154662cb284556acb6c8b6f26c9545;
bytes32 public genesisMintRoot = 0x232450d8a4fb5d9e42138c429c6be5b0a6154662cb284556acb6c8b6f26c9545;
uint256 public genesisHolderPrice = 0.45 ether;
uint256 public publicPrice = 0.57 ether;
bool public isGenesisMintClaimEnabled = false;
bool public isPublicMintEnabled = true;
mapping(address => uint256) public claimedNFTs;
mapping(address => uint256) public mintedNFTs;
uint256 public _idTracker = 118;
uint256 public maxSupply = 1000;
function setclaimRoot(bytes32 newroot) public onlyOwner { }
function setMintRoot(bytes32 newroot) public onlyOwner { }
function setConfig(uint256 _genesisHolderPrice,
uint256 _publicPrice,
bool _isGenesisMintClaimEnabled,
bool _isPublicMintEnabled,
bytes32 _claimRoot,
bytes32 _mintRoot,
uint256 _maxSupply)
public
onlyOwner
{
}
function getAvailableSupply() public view returns (uint256) {
}
function setSupply(uint256 _maxSupply)
public
onlyOwner
{
}
function setIsGenesisMintClaimEnabled(bool isEnabled) public onlyOwner {
}
function setIsPublicMintEnabled(bool isEnabled) public onlyOwner {
}
function getPublicPrice() public view returns (uint256) {
}
function setPublicPrice(uint256 _price)
public
onlyOwner
{
}
function getGenesisHolderPrice() public view returns (uint256) {
}
function setGenesisHolderPrice(uint256 _price)
public
onlyOwner
{
}
function setJIGGIES33Address(address _address) public onlyOwner {
}
function airdrop(
address[] memory to,
uint256[] memory id,
uint256[] memory amount
) onlyOwner public {
}
function setIdTracker(uint256 id) public onlyOwner {
}
function claimGenesisHolder(uint256 amount, uint256 balance, bytes32[] calldata proof) public {
require(isGenesisMintClaimEnabled, "Mint not enabled");
require(_idTracker <= maxSupply, "Not enough supply");
require(MerkleProof.verify(proof, genesisClaimRoot, keccak256(abi.encodePacked(msg.sender, balance))), "Invalid merkle proof");
require(amount > 0, "Amount must be greater than 0");
require(<FILL_ME>)
ERC1155PresetMinterPauser token = ERC1155PresetMinterPauser(jIGGIES33Address);
for(uint256 i = 0; i < amount; i++){
token.mint(msg.sender, _idTracker, 1, "");
_idTracker += 1;
}
claimedNFTs[msg.sender] += amount;
}
function mintGenesisHolder(uint256 amount, uint256 balance, bytes32[] calldata proof) public payable {
}
function mintPublic(uint256 amount) public payable {
}
function withdraw() public onlyOwner {
}
}
| claimedNFTs[msg.sender]+amount<=balance*3,"Wallet already claimed" | 493,394 | claimedNFTs[msg.sender]+amount<=balance*3 |
"Invalid merkle proof" | //
//
//
////////////////////////////////////////////////////////////////////////////////
// //
// ██████ ███████ ████████ ██████ ███████ ███████ ██ ██████ ██████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ███ █████ ██ ██████ █████ █████ ██ █████ █████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██████ ███████ ██ ██ ██ ███████ ███████ ███████ ██████ ██████ //
// //
////////////////////////////////////////////////////////////////////////////////
//
//
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/presets/ERC1155PresetMinterPauser.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract JIGGIES33Minter is Ownable {
address public jIGGIES33Address = 0x476Ae7237d50E01C84d8f04E7C8021909600A898;
bytes32 public genesisClaimRoot = 0x232450d8a4fb5d9e42138c429c6be5b0a6154662cb284556acb6c8b6f26c9545;
bytes32 public genesisMintRoot = 0x232450d8a4fb5d9e42138c429c6be5b0a6154662cb284556acb6c8b6f26c9545;
uint256 public genesisHolderPrice = 0.45 ether;
uint256 public publicPrice = 0.57 ether;
bool public isGenesisMintClaimEnabled = false;
bool public isPublicMintEnabled = true;
mapping(address => uint256) public claimedNFTs;
mapping(address => uint256) public mintedNFTs;
uint256 public _idTracker = 118;
uint256 public maxSupply = 1000;
function setclaimRoot(bytes32 newroot) public onlyOwner { }
function setMintRoot(bytes32 newroot) public onlyOwner { }
function setConfig(uint256 _genesisHolderPrice,
uint256 _publicPrice,
bool _isGenesisMintClaimEnabled,
bool _isPublicMintEnabled,
bytes32 _claimRoot,
bytes32 _mintRoot,
uint256 _maxSupply)
public
onlyOwner
{
}
function getAvailableSupply() public view returns (uint256) {
}
function setSupply(uint256 _maxSupply)
public
onlyOwner
{
}
function setIsGenesisMintClaimEnabled(bool isEnabled) public onlyOwner {
}
function setIsPublicMintEnabled(bool isEnabled) public onlyOwner {
}
function getPublicPrice() public view returns (uint256) {
}
function setPublicPrice(uint256 _price)
public
onlyOwner
{
}
function getGenesisHolderPrice() public view returns (uint256) {
}
function setGenesisHolderPrice(uint256 _price)
public
onlyOwner
{
}
function setJIGGIES33Address(address _address) public onlyOwner {
}
function airdrop(
address[] memory to,
uint256[] memory id,
uint256[] memory amount
) onlyOwner public {
}
function setIdTracker(uint256 id) public onlyOwner {
}
function claimGenesisHolder(uint256 amount, uint256 balance, bytes32[] calldata proof) public {
}
function mintGenesisHolder(uint256 amount, uint256 balance, bytes32[] calldata proof) public payable {
require(isGenesisMintClaimEnabled, "Mint not enabled");
require(_idTracker <= maxSupply, "Not enough supply");
require(<FILL_ME>)
require(msg.value >= genesisHolderPrice * amount, "Not enough eth");
require(amount > 0, "Amount must be greater than 0");
require(mintedNFTs[msg.sender] + amount <= balance * 7, "Wallet already minted");
ERC1155PresetMinterPauser token = ERC1155PresetMinterPauser(jIGGIES33Address);
for(uint256 i = 0; i < amount; i++){
token.mint(msg.sender, _idTracker, 1, "");
_idTracker += 1;
}
mintedNFTs[msg.sender] += amount;
}
function mintPublic(uint256 amount) public payable {
}
function withdraw() public onlyOwner {
}
}
| MerkleProof.verify(proof,genesisMintRoot,keccak256(abi.encodePacked(msg.sender,balance))),"Invalid merkle proof" | 493,394 | MerkleProof.verify(proof,genesisMintRoot,keccak256(abi.encodePacked(msg.sender,balance))) |
"Wallet already minted" | //
//
//
////////////////////////////////////////////////////////////////////////////////
// //
// ██████ ███████ ████████ ██████ ███████ ███████ ██ ██████ ██████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██ ███ █████ ██ ██████ █████ █████ ██ █████ █████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██████ ███████ ██ ██ ██ ███████ ███████ ███████ ██████ ██████ //
// //
////////////////////////////////////////////////////////////////////////////////
//
//
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/presets/ERC1155PresetMinterPauser.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
contract JIGGIES33Minter is Ownable {
address public jIGGIES33Address = 0x476Ae7237d50E01C84d8f04E7C8021909600A898;
bytes32 public genesisClaimRoot = 0x232450d8a4fb5d9e42138c429c6be5b0a6154662cb284556acb6c8b6f26c9545;
bytes32 public genesisMintRoot = 0x232450d8a4fb5d9e42138c429c6be5b0a6154662cb284556acb6c8b6f26c9545;
uint256 public genesisHolderPrice = 0.45 ether;
uint256 public publicPrice = 0.57 ether;
bool public isGenesisMintClaimEnabled = false;
bool public isPublicMintEnabled = true;
mapping(address => uint256) public claimedNFTs;
mapping(address => uint256) public mintedNFTs;
uint256 public _idTracker = 118;
uint256 public maxSupply = 1000;
function setclaimRoot(bytes32 newroot) public onlyOwner { }
function setMintRoot(bytes32 newroot) public onlyOwner { }
function setConfig(uint256 _genesisHolderPrice,
uint256 _publicPrice,
bool _isGenesisMintClaimEnabled,
bool _isPublicMintEnabled,
bytes32 _claimRoot,
bytes32 _mintRoot,
uint256 _maxSupply)
public
onlyOwner
{
}
function getAvailableSupply() public view returns (uint256) {
}
function setSupply(uint256 _maxSupply)
public
onlyOwner
{
}
function setIsGenesisMintClaimEnabled(bool isEnabled) public onlyOwner {
}
function setIsPublicMintEnabled(bool isEnabled) public onlyOwner {
}
function getPublicPrice() public view returns (uint256) {
}
function setPublicPrice(uint256 _price)
public
onlyOwner
{
}
function getGenesisHolderPrice() public view returns (uint256) {
}
function setGenesisHolderPrice(uint256 _price)
public
onlyOwner
{
}
function setJIGGIES33Address(address _address) public onlyOwner {
}
function airdrop(
address[] memory to,
uint256[] memory id,
uint256[] memory amount
) onlyOwner public {
}
function setIdTracker(uint256 id) public onlyOwner {
}
function claimGenesisHolder(uint256 amount, uint256 balance, bytes32[] calldata proof) public {
}
function mintGenesisHolder(uint256 amount, uint256 balance, bytes32[] calldata proof) public payable {
require(isGenesisMintClaimEnabled, "Mint not enabled");
require(_idTracker <= maxSupply, "Not enough supply");
require(MerkleProof.verify(proof, genesisMintRoot, keccak256(abi.encodePacked(msg.sender, balance))), "Invalid merkle proof");
require(msg.value >= genesisHolderPrice * amount, "Not enough eth");
require(amount > 0, "Amount must be greater than 0");
require(<FILL_ME>)
ERC1155PresetMinterPauser token = ERC1155PresetMinterPauser(jIGGIES33Address);
for(uint256 i = 0; i < amount; i++){
token.mint(msg.sender, _idTracker, 1, "");
_idTracker += 1;
}
mintedNFTs[msg.sender] += amount;
}
function mintPublic(uint256 amount) public payable {
}
function withdraw() public onlyOwner {
}
}
| mintedNFTs[msg.sender]+amount<=balance*7,"Wallet already minted" | 493,394 | mintedNFTs[msg.sender]+amount<=balance*7 |
"CONTRACT ERROR: Address has already claimed max amount" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract RoboHiroCollab is ERC1155, Ownable, PaymentSplitter, ReentrancyGuard {
using ECDSA for bytes32;
// public vars
string private _contractUri = "";
string public name = "RoboHiroCollab";
string public symbol = "RHC";
bool public mintingEnabled = true;
mapping(address => uint) public claimedTokens;
// private vars
address private _signer;
constructor(
string memory _initBaseURI,
address[] memory _sharesAddresses,
uint[] memory _sharesEquity,
address signer
)
ERC1155(_initBaseURI)
PaymentSplitter(_sharesAddresses, _sharesEquity){
}
// metadata
function setBaseUri(string calldata newUri) public onlyOwner {
}
function setContractUri(string calldata newUri) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
// using signer technique for managing approved minters
function updateSigner(address signer) external onlyOwner {
}
function _hash(address _address, uint amount, uint allowedAmount, uint256 id, uint cost) internal view returns (bytes32){
}
function _verify(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns (bool){
}
// enable / disable minting
function setMintState(bool _mintingEnabled) public onlyOwner {
}
// minting function
function mint(uint8 v, bytes32 r, bytes32 s, uint256 amount, uint256 allowedAmount, uint256 id) public payable {
require(mintingEnabled, "CONTRACT ERROR: minting has not been enabled");
require(<FILL_ME>)
require(_verify(_hash(msg.sender, amount, allowedAmount, id, msg.value), v, r, s), "CONTRACT ERROR: Invalid signature");
_mint(msg.sender, id, amount, "");
claimedTokens[msg.sender] += amount;
}
}
| claimedTokens[msg.sender]+amount<=allowedAmount,"CONTRACT ERROR: Address has already claimed max amount" | 493,492 | claimedTokens[msg.sender]+amount<=allowedAmount |
"CONTRACT ERROR: Invalid signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/finance/PaymentSplitter.sol";
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
contract RoboHiroCollab is ERC1155, Ownable, PaymentSplitter, ReentrancyGuard {
using ECDSA for bytes32;
// public vars
string private _contractUri = "";
string public name = "RoboHiroCollab";
string public symbol = "RHC";
bool public mintingEnabled = true;
mapping(address => uint) public claimedTokens;
// private vars
address private _signer;
constructor(
string memory _initBaseURI,
address[] memory _sharesAddresses,
uint[] memory _sharesEquity,
address signer
)
ERC1155(_initBaseURI)
PaymentSplitter(_sharesAddresses, _sharesEquity){
}
// metadata
function setBaseUri(string calldata newUri) public onlyOwner {
}
function setContractUri(string calldata newUri) public onlyOwner {
}
function contractURI() public view returns (string memory) {
}
// using signer technique for managing approved minters
function updateSigner(address signer) external onlyOwner {
}
function _hash(address _address, uint amount, uint allowedAmount, uint256 id, uint cost) internal view returns (bytes32){
}
function _verify(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns (bool){
}
// enable / disable minting
function setMintState(bool _mintingEnabled) public onlyOwner {
}
// minting function
function mint(uint8 v, bytes32 r, bytes32 s, uint256 amount, uint256 allowedAmount, uint256 id) public payable {
require(mintingEnabled, "CONTRACT ERROR: minting has not been enabled");
require(claimedTokens[msg.sender] + amount <= allowedAmount, "CONTRACT ERROR: Address has already claimed max amount");
require(<FILL_ME>)
_mint(msg.sender, id, amount, "");
claimedTokens[msg.sender] += amount;
}
}
| _verify(_hash(msg.sender,amount,allowedAmount,id,msg.value),v,r,s),"CONTRACT ERROR: Invalid signature" | 493,492 | _verify(_hash(msg.sender,amount,allowedAmount,id,msg.value),v,r,s) |
"1 free!" | pragma solidity 0.8.17;
contract GatesOfOlympus is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
string private uriPrefix ;
string private uriSuffix = ".json";
string public hiddenURL;
uint256 public maxSupply = 10000;
uint256 public publicPrice = 0.003 ether;
uint256 public MaxFreePerWallet = 1;
uint256 public maxMintAmountPerTX = 10;
uint256 public maxMintAmountPerWallet = 30;
mapping(address => bool) freeMintClaimed; //1 Free NFT per wallet
bool public paused = true;
bool public reveal = false;
constructor(
string memory _tokenName,
string memory _tokenSymbol,
string memory _hiddenMetadataUri
) ERC721A(_tokenName, _tokenSymbol) {}
modifier mintCompliance(uint256 _mintAmount) {
}
function mint(
uint256 _mintAmount
)
public payable
mintCompliance(_mintAmount)
nonReentrant {
require(!paused, "Mint Closed!");
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTX, "Max 10 per TX");
if (freeMintClaimed[_msgSender()]) {
require(msg.value >= _mintAmount * publicPrice, "0.003 per NFT" );
} else {
require(<FILL_ME>)
freeMintClaimed[_msgSender()] = true;
}
_safeMint(_msgSender(), _mintAmount);
}
function OwnerReserve(uint256 _mintAmount, address _to) public onlyOwner {
}
function setPrice(uint256 _publicPrice) public onlyOwner {
}
function setPaused(bool _state) public onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function tokenURI(uint256 _tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setUriPrefix(string memory _uriPrefix) external onlyOwner {
}
function setHiddenUri(string memory _uriPrefix) external onlyOwner {
}
function setRevealed() external onlyOwner{
}
function _baseURI() internal view override returns (string memory) {
}
function _startTokenId() internal pure override returns (uint256) {
}
function withdraw() public onlyOwner {
}
}
| msg.value>=(_mintAmount-1)*publicPrice,"1 free!" | 493,830 | msg.value>=(_mintAmount-1)*publicPrice |
"Max Aliens per wallet during presale is 10" | pragma solidity ^0.8.0;
contract AlienFam is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public baseURI = "ipfs://";
string public hiddenMetadataUri;
uint256 public maxAliens = 5000;
uint256 public Max_Aliens_Per_Wallet_PreSale = 10;
uint256 public Max_Aliens_Per_Wallet_PublicSale = 10;
uint256 public preSaleCost = 0.04 ether;
uint256 public publicSaleCost = 0.06 ether;
uint256 public Max_Aliens_Per_Transaction = 10;
bool public paused = false;
bool public revealed = false;
bool public isPublicSaleActive = false;
bool public isPreSaleActive = true;
bytes32 public RootHash = 0x74f4666169faccda89a45d47ab1997a62f24c3cd534a01539db8f0e40d3eb8b1;
modifier publicSaleActive() {
}
modifier preSaleActive() {
}
modifier salePaused() {
}
modifier maxAliensPreSale(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
modifier maxAliensPublicSale(uint256 numberOfTokens) {
}
modifier canMintAliens(uint256 numberOfTokens) {
}
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor() ERC721("Alien Fam", "ALNFM") {
}
function publicMint(uint256 numberOfTokens)
external
payable
nonReentrant
salePaused
publicSaleActive
canMintAliens(numberOfTokens)
maxAliensPublicSale(numberOfTokens)
isCorrectPayment(publicSaleCost, numberOfTokens)
{
}
function whitelistMint(uint numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
salePaused
preSaleActive
canMintAliens(numberOfTokens)
maxAliensPreSale(numberOfTokens)
isValidMerkleProof(merkleProof, RootHash)
isCorrectPayment(preSaleCost, numberOfTokens)
{
}
// Owner quota for the team and giveaways
function ownerMint(uint256 numberOfTokens, address _receiver)
public
nonReentrant
onlyOwner
canMintAliens(numberOfTokens)
{
}
function nextTokenId() private returns (uint256) {
}
// function getBaseURI() external view returns (string memory) {
// return baseURI;
// }
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function getTotalSupply() public view returns (uint256) {
}
function setRevealed(bool _state) external onlyOwner {
}
function setRootHash(bytes32 _Root) external onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function openPreSale(bool _state) external onlyOwner {
}
function openPublicSale(bool _state) external onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setPresaleCost(uint256 _cost) external onlyOwner {
}
function setPublicSaleCost(uint256 _cost) external onlyOwner {
}
function setMaxAliensPerTx(uint256 _maxAliensPerTx) external onlyOwner {
}
function setPreSaleWalletLimit(uint256 _PreSaleWalletLimit) external onlyOwner {
}
function setPublicSaleWalletLimit(uint256 _PublicSaleWalletLimit) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+numberOfTokens<=Max_Aliens_Per_Wallet_PreSale,"Max Aliens per wallet during presale is 10" | 493,844 | balanceOf(msg.sender)+numberOfTokens<=Max_Aliens_Per_Wallet_PreSale |
"Max Aliens per wallet during public sale is 10" | pragma solidity ^0.8.0;
contract AlienFam is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public baseURI = "ipfs://";
string public hiddenMetadataUri;
uint256 public maxAliens = 5000;
uint256 public Max_Aliens_Per_Wallet_PreSale = 10;
uint256 public Max_Aliens_Per_Wallet_PublicSale = 10;
uint256 public preSaleCost = 0.04 ether;
uint256 public publicSaleCost = 0.06 ether;
uint256 public Max_Aliens_Per_Transaction = 10;
bool public paused = false;
bool public revealed = false;
bool public isPublicSaleActive = false;
bool public isPreSaleActive = true;
bytes32 public RootHash = 0x74f4666169faccda89a45d47ab1997a62f24c3cd534a01539db8f0e40d3eb8b1;
modifier publicSaleActive() {
}
modifier preSaleActive() {
}
modifier salePaused() {
}
modifier maxAliensPreSale(uint256 numberOfTokens) {
}
modifier maxAliensPublicSale(uint256 numberOfTokens) {
require(<FILL_ME>)
_;
}
modifier canMintAliens(uint256 numberOfTokens) {
}
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor() ERC721("Alien Fam", "ALNFM") {
}
function publicMint(uint256 numberOfTokens)
external
payable
nonReentrant
salePaused
publicSaleActive
canMintAliens(numberOfTokens)
maxAliensPublicSale(numberOfTokens)
isCorrectPayment(publicSaleCost, numberOfTokens)
{
}
function whitelistMint(uint numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
salePaused
preSaleActive
canMintAliens(numberOfTokens)
maxAliensPreSale(numberOfTokens)
isValidMerkleProof(merkleProof, RootHash)
isCorrectPayment(preSaleCost, numberOfTokens)
{
}
// Owner quota for the team and giveaways
function ownerMint(uint256 numberOfTokens, address _receiver)
public
nonReentrant
onlyOwner
canMintAliens(numberOfTokens)
{
}
function nextTokenId() private returns (uint256) {
}
// function getBaseURI() external view returns (string memory) {
// return baseURI;
// }
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function getTotalSupply() public view returns (uint256) {
}
function setRevealed(bool _state) external onlyOwner {
}
function setRootHash(bytes32 _Root) external onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function openPreSale(bool _state) external onlyOwner {
}
function openPublicSale(bool _state) external onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setPresaleCost(uint256 _cost) external onlyOwner {
}
function setPublicSaleCost(uint256 _cost) external onlyOwner {
}
function setMaxAliensPerTx(uint256 _maxAliensPerTx) external onlyOwner {
}
function setPreSaleWalletLimit(uint256 _PreSaleWalletLimit) external onlyOwner {
}
function setPublicSaleWalletLimit(uint256 _PublicSaleWalletLimit) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| balanceOf(msg.sender)+numberOfTokens<=Max_Aliens_Per_Wallet_PublicSale,"Max Aliens per wallet during public sale is 10" | 493,844 | balanceOf(msg.sender)+numberOfTokens<=Max_Aliens_Per_Wallet_PublicSale |
"Not enough Aliens remaining to mint" | pragma solidity ^0.8.0;
contract AlienFam is ERC721, Ownable, ReentrancyGuard {
using Strings for uint256;
using Counters for Counters.Counter;
Counters.Counter private supply;
string public baseURI = "ipfs://";
string public hiddenMetadataUri;
uint256 public maxAliens = 5000;
uint256 public Max_Aliens_Per_Wallet_PreSale = 10;
uint256 public Max_Aliens_Per_Wallet_PublicSale = 10;
uint256 public preSaleCost = 0.04 ether;
uint256 public publicSaleCost = 0.06 ether;
uint256 public Max_Aliens_Per_Transaction = 10;
bool public paused = false;
bool public revealed = false;
bool public isPublicSaleActive = false;
bool public isPreSaleActive = true;
bytes32 public RootHash = 0x74f4666169faccda89a45d47ab1997a62f24c3cd534a01539db8f0e40d3eb8b1;
modifier publicSaleActive() {
}
modifier preSaleActive() {
}
modifier salePaused() {
}
modifier maxAliensPreSale(uint256 numberOfTokens) {
}
modifier maxAliensPublicSale(uint256 numberOfTokens) {
}
modifier canMintAliens(uint256 numberOfTokens) {
require(<FILL_ME>)
require(
numberOfTokens > 0 && numberOfTokens <= Max_Aliens_Per_Transaction, "Invalid mint amount!"
);
_;
}
modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) {
}
modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root) {
}
constructor() ERC721("Alien Fam", "ALNFM") {
}
function publicMint(uint256 numberOfTokens)
external
payable
nonReentrant
salePaused
publicSaleActive
canMintAliens(numberOfTokens)
maxAliensPublicSale(numberOfTokens)
isCorrectPayment(publicSaleCost, numberOfTokens)
{
}
function whitelistMint(uint numberOfTokens, bytes32[] calldata merkleProof)
external
payable
nonReentrant
salePaused
preSaleActive
canMintAliens(numberOfTokens)
maxAliensPreSale(numberOfTokens)
isValidMerkleProof(merkleProof, RootHash)
isCorrectPayment(preSaleCost, numberOfTokens)
{
}
// Owner quota for the team and giveaways
function ownerMint(uint256 numberOfTokens, address _receiver)
public
nonReentrant
onlyOwner
canMintAliens(numberOfTokens)
{
}
function nextTokenId() private returns (uint256) {
}
// function getBaseURI() external view returns (string memory) {
// return baseURI;
// }
function setBaseURI(string memory _baseURI) external onlyOwner {
}
function getTotalSupply() public view returns (uint256) {
}
function setRevealed(bool _state) external onlyOwner {
}
function setRootHash(bytes32 _Root) external onlyOwner {
}
function setPaused(bool _state) external onlyOwner {
}
function openPreSale(bool _state) external onlyOwner {
}
function openPublicSale(bool _state) external onlyOwner {
}
function walletOfOwner(address _owner)
public
view
returns (uint256[] memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function setPresaleCost(uint256 _cost) external onlyOwner {
}
function setPublicSaleCost(uint256 _cost) external onlyOwner {
}
function setMaxAliensPerTx(uint256 _maxAliensPerTx) external onlyOwner {
}
function setPreSaleWalletLimit(uint256 _PreSaleWalletLimit) external onlyOwner {
}
function setPublicSaleWalletLimit(uint256 _PublicSaleWalletLimit) external onlyOwner {
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
}
function withdraw() public onlyOwner {
}
}
| supply.current()+numberOfTokens<=maxAliens,"Not enough Aliens remaining to mint" | 493,844 | supply.current()+numberOfTokens<=maxAliens |
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC1155/ERC1155.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155URIStorage.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract Millionaireasia1155Contract is ERC2981, ERC1155Supply, Ownable {
using Strings for uint256;
struct ApprovedAddress {
mapping(address => bool) addresses;
}
struct OwnedTokens {
mapping(uint256 => ApprovedAddress) tokens;
}
struct BuyRequest {
address seller;
uint256 tokenId;
uint256 quantity;
uint256 amount;
uint256 fee;
}
struct BuyBatchRequest {
address seller;
uint256[] tokenIds;
uint256[] quantities;
uint256[] amounts;
uint256[] fees;
}
// Optional base URI
string private _baseURI = "";
mapping(uint256 => string) private _tokenURIs;
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => address[]) private _tokenOwners;
mapping(uint256 => uint256) private _ownedTokensIndex;
mapping(uint256 => uint256) private _allTokensIndex;
mapping(uint256 => address) private creators;
mapping(address => OwnedTokens) private _tokenApprovals;
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
string public name;
string public symbol;
constructor(string memory _name, string memory _symbol) {
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, ERC2981)
returns (bool)
{
}
function mint(address to, uint256 id, uint256 amount, string memory uri, address royaltyRecipient, uint96 royaltyValue) external payable {
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, string[] memory uris, address[] memory royaltyRecipients, uint96[] memory royaltyValues ) external payable {
}
function creator(uint256 tokenId) public view returns (address) {
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function ownersOfTokens(uint256 tokenId) public view returns (address[] memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal virtual {
}
function _setBaseURI(string memory baseURI) external virtual onlyOwner {
}
function approve(address to, uint256 tokenId, uint256 quantity) public virtual {
}
function approveBatch(address to, uint256[] memory tokenIds, uint256[] memory quantities) public virtual {
}
function getApproved(uint256 tokenId, address owner, address operator) public view returns(bool) {
}
modifier onlyApproved(uint256 tokenId, address owner, address operator) {
require(exists(tokenId), "ERC1155: approved query for nonexistent token");
require(<FILL_ME>)
_;
}
modifier onlyApprovers(uint256[] memory tokenIds, address owner, address operator) {
}
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) public virtual override {
}
function safeTransferFromWithFee(address from, address to, uint256 id, uint256 amount, bytes memory data) public payable {
}
function safeBatchTransferFrom(address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public virtual override {
}
function safeBatchTransferFrom(address from, address[] memory tos, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public payable {
}
function buy(BuyRequest memory request) external payable onlyApproved(request.tokenId, request.seller, msg.sender) {
}
function buyBatch(BuyBatchRequest memory request) external payable onlyApprovers(request.tokenIds, request.seller, msg.sender) {
}
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addOwnerToTokenEnumeration(address to, uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeOwnerFromTokenEnumeration(address from, uint256 tokenId) private {
}
}
| _tokenApprovals[owner].tokens[tokenId].addresses[operator] | 493,965 | _tokenApprovals[owner].tokens[tokenId].addresses[operator] |
null | //SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import '@openzeppelin/contracts/token/ERC1155/ERC1155.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol';
import '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155URIStorage.sol';
import '@openzeppelin/contracts/token/common/ERC2981.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
contract Millionaireasia1155Contract is ERC2981, ERC1155Supply, Ownable {
using Strings for uint256;
struct ApprovedAddress {
mapping(address => bool) addresses;
}
struct OwnedTokens {
mapping(uint256 => ApprovedAddress) tokens;
}
struct BuyRequest {
address seller;
uint256 tokenId;
uint256 quantity;
uint256 amount;
uint256 fee;
}
struct BuyBatchRequest {
address seller;
uint256[] tokenIds;
uint256[] quantities;
uint256[] amounts;
uint256[] fees;
}
// Optional base URI
string private _baseURI = "";
mapping(uint256 => string) private _tokenURIs;
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => address[]) private _tokenOwners;
mapping(uint256 => uint256) private _ownedTokensIndex;
mapping(uint256 => uint256) private _allTokensIndex;
mapping(uint256 => address) private creators;
mapping(address => OwnedTokens) private _tokenApprovals;
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
string public name;
string public symbol;
constructor(string memory _name, string memory _symbol) {
}
/// @inheritdoc ERC165
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC1155, ERC2981)
returns (bool)
{
}
function mint(address to, uint256 id, uint256 amount, string memory uri, address royaltyRecipient, uint96 royaltyValue) external payable {
}
function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, string[] memory uris, address[] memory royaltyRecipients, uint96[] memory royaltyValues ) external payable {
}
function creator(uint256 tokenId) public view returns (address) {
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
}
function ownersOfTokens(uint256 tokenId) public view returns (address[] memory) {
}
function _setTokenURI(uint256 tokenId, string memory uri) internal virtual {
}
function _setBaseURI(string memory baseURI) external virtual onlyOwner {
}
function approve(address to, uint256 tokenId, uint256 quantity) public virtual {
}
function approveBatch(address to, uint256[] memory tokenIds, uint256[] memory quantities) public virtual {
}
function getApproved(uint256 tokenId, address owner, address operator) public view returns(bool) {
}
modifier onlyApproved(uint256 tokenId, address owner, address operator) {
}
modifier onlyApprovers(uint256[] memory tokenIds, address owner, address operator) {
for (uint256 i; i < tokenIds.length; i++) {
require(exists(tokenIds[i]), "ERC1155: approved query for nonexistent token");
require(<FILL_ME>)
}
_;
}
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) public virtual override {
}
function safeTransferFromWithFee(address from, address to, uint256 id, uint256 amount, bytes memory data) public payable {
}
function safeBatchTransferFrom(address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public virtual override {
}
function safeBatchTransferFrom(address from, address[] memory tos, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public payable {
}
function buy(BuyRequest memory request) external payable onlyApproved(request.tokenId, request.seller, msg.sender) {
}
function buyBatch(BuyBatchRequest memory request) external payable onlyApprovers(request.tokenIds, request.seller, msg.sender) {
}
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
}
function _addOwnerToTokenEnumeration(address to, uint256 tokenId) private {
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
}
function _removeOwnerFromTokenEnumeration(address from, uint256 tokenId) private {
}
}
| _tokenApprovals[owner].tokens[tokenIds[i]].addresses[operator] | 493,965 | _tokenApprovals[owner].tokens[tokenIds[i]].addresses[operator] |
"Wallet already claimed" | //
//
//
/////////////////////////////////////////////////////////////////
// //
// ██████ ███████ ███ ██ ███ ██ ██ ███████ //
// ██ ██ ██ ████ ██ ████ ██ ██ ██ //
// ██ ██ █████ ██ ██ ██ ██ ██ ██ ██ ███████ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ //
// ██████ ███████ ██ ████ ██ ████ ██ ███████ //
// //
// ███████ ██████ ██ ██ ███ ███ ███████ ██ ███████ //
// ██ ██ ██ ██ ████ ████ ██ ██ ███ //
// ███████ ██ ███████ ██ ████ ██ █████ ██ ███ //
// ██ ██ ██ ██ ██ ██ ██ ██ ██ ███ //
// ███████ ██████ ██ ██ ██ ██ ███████ ███████ ███████ //
// //
/////////////////////////////////////////////////////////////////
//
//
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.14;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/presets/ERC1155PresetMinterPauser.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract AufReisenHolderCollectionMinter is Ownable {
address public aufReisenHolderCollectionAddress = 0x5f8fFe705917eddC406a4273a120BE7Be125A46f;
bool public isMintEnabled = true;
using Counters for Counters.Counter;
Counters.Counter private _idTracker;
mapping(uint256 => mapping(address => uint256)) public waveMints;
uint currentWave = 0;
constructor() {}
function setIsMintEnabled(bool isEnabled) public onlyOwner {
}
function airdrop(
address[] memory to,
uint256[] memory id,
uint256[] memory amount
) onlyOwner public {
}
function mint() public {
require(isMintEnabled, "Mint not enabled");
require(<FILL_ME>)
ERC1155PresetMinterPauser token = ERC1155PresetMinterPauser(aufReisenHolderCollectionAddress);
token.mint(msg.sender, _idTracker.current(), 1, "");
_idTracker.increment();
waveMints[currentWave][msg.sender] += 1;
}
function withdraw() public onlyOwner {
}
function getBalance() public view returns (uint256) {
}
function setCurrentWave(uint _currentWave) public onlyOwner {
}
function setAufReisenHolderCollectionAddress(address newAddress) public onlyOwner {
}
}
| waveMints[currentWave][msg.sender]<1,"Wallet already claimed" | 493,999 | waveMints[currentWave][msg.sender]<1 |
"MafiaDogs: invalid signature" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC4907.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract MafiaDogs is ERC4907, Ownable {
string public baseTokenURI;
bool public presaleIsActive;
bool public publicSaleIsActive;
uint256 public presalePrice;
uint256 public publicSalePrice;
uint256 public alMints;
uint256 public ogMints;
uint256 public maxMints;
address private _signer;
uint256 public constant MAX_SUPPLY = 7777;
uint8 private constant _PUBLIC_MINT = 0;
uint8 private constant _AL_MINT = 1;
uint8 private constant _OG_MINT = 2;
constructor(
string memory _baseTokenURI,
uint256 _presalePrice,
uint256 _publicSalePrice,
address signer_,
uint256 _alMints,
uint256 _ogMints,
uint256 _maxMints
) ERC721A("MafiaDogs", "MD") {
}
function adminMint(address recipient, uint256 quantity) external onlyOwner {
}
function mint(uint8 mintType, uint256 quantity, bytes memory signature) external payable {
require(tx.origin == msg.sender, "MafiaDogs: externally-owned account only");
require(<FILL_ME>)
require(totalSupply() + quantity <= MAX_SUPPLY, "MafiaDogs: MAX_SUPPLY exceeded");
uint256 costToMint;
if (mintType == _AL_MINT) {
require(presaleIsActive, "MafiaDogs: presale is not active");
require(_numberMinted(msg.sender) + quantity <= alMints, "MafiaDogs: alMints exceeded");
costToMint = quantity * presalePrice;
} else if (mintType == _OG_MINT) {
require(presaleIsActive, "MafiaDogs: presale is not active");
require(_numberMinted(msg.sender) + quantity <= ogMints, "MafiaDogs: ogMints exceeded");
costToMint = quantity * presalePrice;
} else if (mintType == _PUBLIC_MINT) {
require(publicSaleIsActive, "MafiaDogs: public sale is not active");
require(_numberMinted(msg.sender) + quantity <= maxMints, "MafiaDogs: maxMints exceeded");
costToMint = quantity * publicSalePrice;
} else {
revert("MafiaDogs: invalid mint type");
}
require(msg.value >= costToMint, "MafiaDogs: insufficient value");
if (msg.value > costToMint) {
payable(msg.sender).transfer(msg.value - costToMint);
}
_mint(msg.sender, quantity);
}
function setBaseURI(string memory _baseTokenURI) external onlyOwner {
}
function setSigner(address signer_) external onlyOwner {
}
function setSaleState(bool _presaleIsActive, bool _publicSaleIsActive) external onlyOwner {
}
function setPrices(uint256 _presalePrice, uint256 _publicSalePrice) external onlyOwner {
}
function setMaxMints(uint256 _alMints, uint256 _ogMints, uint256 _maxMints) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function numberMinted(address addr) external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function _verifySignature(uint8 type_, bytes memory signature) private view returns (bool) {
}
}
| _verifySignature(mintType,signature),"MafiaDogs: invalid signature" | 494,232 | _verifySignature(mintType,signature) |
"MafiaDogs: alMints exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC4907.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract MafiaDogs is ERC4907, Ownable {
string public baseTokenURI;
bool public presaleIsActive;
bool public publicSaleIsActive;
uint256 public presalePrice;
uint256 public publicSalePrice;
uint256 public alMints;
uint256 public ogMints;
uint256 public maxMints;
address private _signer;
uint256 public constant MAX_SUPPLY = 7777;
uint8 private constant _PUBLIC_MINT = 0;
uint8 private constant _AL_MINT = 1;
uint8 private constant _OG_MINT = 2;
constructor(
string memory _baseTokenURI,
uint256 _presalePrice,
uint256 _publicSalePrice,
address signer_,
uint256 _alMints,
uint256 _ogMints,
uint256 _maxMints
) ERC721A("MafiaDogs", "MD") {
}
function adminMint(address recipient, uint256 quantity) external onlyOwner {
}
function mint(uint8 mintType, uint256 quantity, bytes memory signature) external payable {
require(tx.origin == msg.sender, "MafiaDogs: externally-owned account only");
require(_verifySignature(mintType, signature), "MafiaDogs: invalid signature");
require(totalSupply() + quantity <= MAX_SUPPLY, "MafiaDogs: MAX_SUPPLY exceeded");
uint256 costToMint;
if (mintType == _AL_MINT) {
require(presaleIsActive, "MafiaDogs: presale is not active");
require(<FILL_ME>)
costToMint = quantity * presalePrice;
} else if (mintType == _OG_MINT) {
require(presaleIsActive, "MafiaDogs: presale is not active");
require(_numberMinted(msg.sender) + quantity <= ogMints, "MafiaDogs: ogMints exceeded");
costToMint = quantity * presalePrice;
} else if (mintType == _PUBLIC_MINT) {
require(publicSaleIsActive, "MafiaDogs: public sale is not active");
require(_numberMinted(msg.sender) + quantity <= maxMints, "MafiaDogs: maxMints exceeded");
costToMint = quantity * publicSalePrice;
} else {
revert("MafiaDogs: invalid mint type");
}
require(msg.value >= costToMint, "MafiaDogs: insufficient value");
if (msg.value > costToMint) {
payable(msg.sender).transfer(msg.value - costToMint);
}
_mint(msg.sender, quantity);
}
function setBaseURI(string memory _baseTokenURI) external onlyOwner {
}
function setSigner(address signer_) external onlyOwner {
}
function setSaleState(bool _presaleIsActive, bool _publicSaleIsActive) external onlyOwner {
}
function setPrices(uint256 _presalePrice, uint256 _publicSalePrice) external onlyOwner {
}
function setMaxMints(uint256 _alMints, uint256 _ogMints, uint256 _maxMints) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function numberMinted(address addr) external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function _verifySignature(uint8 type_, bytes memory signature) private view returns (bool) {
}
}
| _numberMinted(msg.sender)+quantity<=alMints,"MafiaDogs: alMints exceeded" | 494,232 | _numberMinted(msg.sender)+quantity<=alMints |
"MafiaDogs: ogMints exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC4907.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract MafiaDogs is ERC4907, Ownable {
string public baseTokenURI;
bool public presaleIsActive;
bool public publicSaleIsActive;
uint256 public presalePrice;
uint256 public publicSalePrice;
uint256 public alMints;
uint256 public ogMints;
uint256 public maxMints;
address private _signer;
uint256 public constant MAX_SUPPLY = 7777;
uint8 private constant _PUBLIC_MINT = 0;
uint8 private constant _AL_MINT = 1;
uint8 private constant _OG_MINT = 2;
constructor(
string memory _baseTokenURI,
uint256 _presalePrice,
uint256 _publicSalePrice,
address signer_,
uint256 _alMints,
uint256 _ogMints,
uint256 _maxMints
) ERC721A("MafiaDogs", "MD") {
}
function adminMint(address recipient, uint256 quantity) external onlyOwner {
}
function mint(uint8 mintType, uint256 quantity, bytes memory signature) external payable {
require(tx.origin == msg.sender, "MafiaDogs: externally-owned account only");
require(_verifySignature(mintType, signature), "MafiaDogs: invalid signature");
require(totalSupply() + quantity <= MAX_SUPPLY, "MafiaDogs: MAX_SUPPLY exceeded");
uint256 costToMint;
if (mintType == _AL_MINT) {
require(presaleIsActive, "MafiaDogs: presale is not active");
require(_numberMinted(msg.sender) + quantity <= alMints, "MafiaDogs: alMints exceeded");
costToMint = quantity * presalePrice;
} else if (mintType == _OG_MINT) {
require(presaleIsActive, "MafiaDogs: presale is not active");
require(<FILL_ME>)
costToMint = quantity * presalePrice;
} else if (mintType == _PUBLIC_MINT) {
require(publicSaleIsActive, "MafiaDogs: public sale is not active");
require(_numberMinted(msg.sender) + quantity <= maxMints, "MafiaDogs: maxMints exceeded");
costToMint = quantity * publicSalePrice;
} else {
revert("MafiaDogs: invalid mint type");
}
require(msg.value >= costToMint, "MafiaDogs: insufficient value");
if (msg.value > costToMint) {
payable(msg.sender).transfer(msg.value - costToMint);
}
_mint(msg.sender, quantity);
}
function setBaseURI(string memory _baseTokenURI) external onlyOwner {
}
function setSigner(address signer_) external onlyOwner {
}
function setSaleState(bool _presaleIsActive, bool _publicSaleIsActive) external onlyOwner {
}
function setPrices(uint256 _presalePrice, uint256 _publicSalePrice) external onlyOwner {
}
function setMaxMints(uint256 _alMints, uint256 _ogMints, uint256 _maxMints) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function numberMinted(address addr) external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function _verifySignature(uint8 type_, bytes memory signature) private view returns (bool) {
}
}
| _numberMinted(msg.sender)+quantity<=ogMints,"MafiaDogs: ogMints exceeded" | 494,232 | _numberMinted(msg.sender)+quantity<=ogMints |
"MafiaDogs: maxMints exceeded" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./ERC4907.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
contract MafiaDogs is ERC4907, Ownable {
string public baseTokenURI;
bool public presaleIsActive;
bool public publicSaleIsActive;
uint256 public presalePrice;
uint256 public publicSalePrice;
uint256 public alMints;
uint256 public ogMints;
uint256 public maxMints;
address private _signer;
uint256 public constant MAX_SUPPLY = 7777;
uint8 private constant _PUBLIC_MINT = 0;
uint8 private constant _AL_MINT = 1;
uint8 private constant _OG_MINT = 2;
constructor(
string memory _baseTokenURI,
uint256 _presalePrice,
uint256 _publicSalePrice,
address signer_,
uint256 _alMints,
uint256 _ogMints,
uint256 _maxMints
) ERC721A("MafiaDogs", "MD") {
}
function adminMint(address recipient, uint256 quantity) external onlyOwner {
}
function mint(uint8 mintType, uint256 quantity, bytes memory signature) external payable {
require(tx.origin == msg.sender, "MafiaDogs: externally-owned account only");
require(_verifySignature(mintType, signature), "MafiaDogs: invalid signature");
require(totalSupply() + quantity <= MAX_SUPPLY, "MafiaDogs: MAX_SUPPLY exceeded");
uint256 costToMint;
if (mintType == _AL_MINT) {
require(presaleIsActive, "MafiaDogs: presale is not active");
require(_numberMinted(msg.sender) + quantity <= alMints, "MafiaDogs: alMints exceeded");
costToMint = quantity * presalePrice;
} else if (mintType == _OG_MINT) {
require(presaleIsActive, "MafiaDogs: presale is not active");
require(_numberMinted(msg.sender) + quantity <= ogMints, "MafiaDogs: ogMints exceeded");
costToMint = quantity * presalePrice;
} else if (mintType == _PUBLIC_MINT) {
require(publicSaleIsActive, "MafiaDogs: public sale is not active");
require(<FILL_ME>)
costToMint = quantity * publicSalePrice;
} else {
revert("MafiaDogs: invalid mint type");
}
require(msg.value >= costToMint, "MafiaDogs: insufficient value");
if (msg.value > costToMint) {
payable(msg.sender).transfer(msg.value - costToMint);
}
_mint(msg.sender, quantity);
}
function setBaseURI(string memory _baseTokenURI) external onlyOwner {
}
function setSigner(address signer_) external onlyOwner {
}
function setSaleState(bool _presaleIsActive, bool _publicSaleIsActive) external onlyOwner {
}
function setPrices(uint256 _presalePrice, uint256 _publicSalePrice) external onlyOwner {
}
function setMaxMints(uint256 _alMints, uint256 _ogMints, uint256 _maxMints) public onlyOwner {
}
function withdraw() external onlyOwner {
}
function numberMinted(address addr) external view returns (uint256) {
}
function _baseURI() internal view override returns (string memory) {
}
function _verifySignature(uint8 type_, bytes memory signature) private view returns (bool) {
}
}
| _numberMinted(msg.sender)+quantity<=maxMints,"MafiaDogs: maxMints exceeded" | 494,232 | _numberMinted(msg.sender)+quantity<=maxMints |
"initialUnlock too high" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
import "./Claim.sol";
contract ClaimConfigurable is Claim {
constructor(
uint256 _claimTime,
address _token,
uint256[4] memory vestingData
) Claim(_claimTime, _token) {
require(<FILL_ME>)
initialUnlock = vestingData[0];
cliff = vestingData[1];
vesting = vestingData[2];
vestingInterval = vestingData[3];
}
}
| vestingData[0]<=BASE_POINTS,"initialUnlock too high" | 494,239 | vestingData[0]<=BASE_POINTS |
"Cannot set maxTransactionAmount lower than 0.1%" | pragma solidity ^0.8.17;
pragma experimental ABIEncoderV2;
contract SHIKBA is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address private marketingWallet;
address private developmentWallet;
uint256 public maxBuyTransactionAmount;
uint256 public maxSellTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public launchBlock;
uint256 public percentForLPBurn = 0;
bool public lpBurnEnabled = false;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevelopmentFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevelopmentFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public bots;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event developmentWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("SHIKBA INU", "SHIKBA") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
function removeLimits() external onlyOwner returns (bool) {
}
function disableTransferDelay() external onlyOwner returns (bool) {
}
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNumBuy, uint256 newNumSell) external onlyOwner {
require(<FILL_ME>)
maxBuyTransactionAmount = newNumBuy * (10 ** 18);
maxSellTransactionAmount = newNumSell * (10 ** 18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _developmentFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _developmentFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWalletInfo(address newMarketingWallet)
external
onlyOwner
{
}
function updateDevelopmentWalletInfo(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
}
function blockBots(address[] memory bots_) external onlyOwner {
}
function unblockBot(address notbot) external onlyOwner {
}
}
| newNumBuy>=((totalSupply()*1)/1000)/1e18&&newNumSell>=((totalSupply()*1)/1000)/1e18,"Cannot set maxTransactionAmount lower than 0.1%" | 494,246 | newNumBuy>=((totalSupply()*1)/1000)/1e18&&newNumSell>=((totalSupply()*1)/1000)/1e18 |
"TOKEN: Your account is blacklisted!" | pragma solidity ^0.8.17;
pragma experimental ABIEncoderV2;
contract SHIKBA is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address private marketingWallet;
address private developmentWallet;
uint256 public maxBuyTransactionAmount;
uint256 public maxSellTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public launchBlock;
uint256 public percentForLPBurn = 0;
bool public lpBurnEnabled = false;
uint256 public lpBurnFrequency = 3600 seconds;
uint256 public lastLpBurnTime;
uint256 public manualBurnFrequency = 30 minutes;
uint256 public lastManualLpBurnTime;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = true;
mapping(address => uint256) private _holderLastTransferTimestamp;
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevelopmentFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevelopmentFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) public bots;
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event developmentWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event AutoNukeLP();
event ManualNukeLP();
constructor() ERC20("SHIKBA INU", "SHIKBA") {
}
receive() external payable {}
function enableTrading() external onlyOwner {
}
function removeLimits() external onlyOwner returns (bool) {
}
function disableTransferDelay() external onlyOwner returns (bool) {
}
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNumBuy, uint256 newNumSell) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _developmentFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _developmentFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWalletInfo(address newMarketingWallet)
external
onlyOwner
{
}
function updateDevelopmentWalletInfo(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(<FILL_ME>)
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (block.timestamp == launchBlock && from == uniswapV2Pair) {
bots[to] = true;
}
if (limitsInEffect) {
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled) {
if (
to != owner() &&
to != address(uniswapV2Router) &&
to != address(uniswapV2Pair)
) {
require(
_holderLastTransferTimestamp[tx.origin] <
block.number,
"_transfer:: Transfer Delay enabled. Only one purchase per block allowed."
);
_holderLastTransferTimestamp[tx.origin] = block.number;
}
}
//when buy
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxBuyTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
//when sell
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxSellTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
if (
!swapping &&
automatedMarketMakerPairs[to] &&
lpBurnEnabled &&
block.timestamp >= lastLpBurnTime + lpBurnFrequency &&
!_isExcludedFromFees[from]
) {
autoBurnLiquidityPairTokens();
}
bool takeFee = !swapping;
// if any account belongs to _isExcludedFromFee account then remove the fee
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if (takeFee) {
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = amount.mul(sellTotalFees).div(100);
tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
tokensForDev += (fees * sellDevelopmentFee) / sellTotalFees;
tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
}
// on buy
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount.mul(buyTotalFees).div(100);
tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
tokensForDev += (fees * buyDevelopmentFee) / buyTotalFees;
tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function setAutoLPBurnSettings(
uint256 _frequencyInSeconds,
uint256 _percent,
bool _Enabled
) external onlyOwner {
}
function autoBurnLiquidityPairTokens() internal returns (bool) {
}
function manualBurnLiquidityPairTokens(uint256 percent)
external
onlyOwner
returns (bool)
{
}
function blockBots(address[] memory bots_) external onlyOwner {
}
function unblockBot(address notbot) external onlyOwner {
}
}
| !bots[from]&&!bots[to]&&!bots[tx.origin],"TOKEN: Your account is blacklisted!" | 494,246 | !bots[from]&&!bots[to]&&!bots[tx.origin] |
"Already added" | pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "./interface/IxAsset.sol";
import "./interface/IOrigination.sol";
import "./interface/IxTokenManager.sol";
/**
* @title RevenueController
* @author xToken
*
* RevenueController is the management fees charged on xAsset funds. The RevenueController contract
* claims fees from xAssets, exchanges fee tokens for XTK via 1inch (off-chain api data will need to
* be passed to permissioned function `claimAndSwap`), and then transfers XTK to Mgmt module
*/
contract RevenueController is Initializable, OwnableUpgradeable {
using SafeERC20 for IERC20;
/* ============ State Variables ============ */
// Index of xAsset
uint256 public nextFundIndex;
// Address of xtk token
address public constant xtk = 0x7F3EDcdD180Dbe4819Bd98FeE8929b5cEdB3AdEB;
// Address of Mgmt module
address public managementStakingModule;
// Address of OneInchExchange contract
address public oneInchExchange;
// Address to indicate ETH
address private constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
//
address public xtokenManager;
// xAsset to index
mapping(address => uint256) private _fundToIndex;
// xAsset to array of asset address that charged as fee
mapping(address => address[]) private _fundAssets;
// Index to xAsset
mapping(uint256 => address) private _indexToFund;
address public constant terminal = 0x090559D58aAB8828C27eE7a7EAb18efD5bB90374;
address public constant AGGREGATION_ROUTER_V4 = 0x1111111254fb6c44bAC0beD2854e76F90643097d;
address public origination;
/* ============ Events ============ */
event FeesClaimed(address indexed fund, address indexed revenueToken, uint256 revenueTokenAmount);
event RevenueAccrued(address indexed fund, uint256 xtkAccrued, uint256 timestamp);
event FundAdded(address indexed fund, uint256 indexed fundIndex);
event AssetSwappedToXtk(address indexed fundAssets, uint256 fundAssetAmount, uint256 xtkAmount);
/* ============ Modifiers ============ */
modifier onlyOwnerOrManager() {
}
/* ============ Functions ============ */
function initialize(
address _managementStakingModule,
address _oneInchExchange,
address _xtokenManager
) external initializer {
}
/**
* Withdraw fees from xAsset contract, and swap fee assets into xtk token and send to Mgmt
*
* @param _fundIndex Index of xAsset
* @param _oneInchData 1inch low-level calldata(generated off-chain)
*/
function claimAndSwap(
uint256 _fundIndex,
bytes[] calldata _oneInchData,
uint256[] calldata _callValue
) external onlyOwnerOrManager {
}
function claimTerminalFeesAndSwap(
address _token,
bytes calldata _oneInchData,
uint256 _callValue
) external onlyOwnerOrManager {
}
function swapTerminalETH(bytes calldata _oneInchData, uint256 _callValue) external onlyOwnerOrManager {
}
function claimOriginationFeesAndSwap(
address _token,
bytes calldata _oneInchData,
uint256 _callValue
) external onlyOwnerOrManager {
}
function swapOriginationETH(bytes calldata _oneInchData, uint256 _callValue) external onlyOwnerOrManager {
}
function swapAssetOnceClaimed(
address fund,
address asset,
bytes calldata _oneInchData,
uint256 _callValue
) external onlyOwnerOrManager {
}
function swapOnceClaimed(
uint256 _fundIndex,
uint256 _fundAssetIndex,
bytes calldata _oneInchData,
uint256 _callValue
) external onlyOwnerOrManager {
}
function swapAssetToXtk(
address _fundAsset,
bytes memory _oneInchData,
uint256 _callValue
) private {
}
function claimXtkForStaking(address _fund) private {
}
function snapshotTargetAssetAndXtkBalance(address _fundAsset) private view returns (uint256, uint256) {
}
/**
* Governance function that adds xAssets
* @param _fund Address of xAsset
* @param _assets Assets charged as fee in xAsset
*/
function addFund(address _fund, address[] memory _assets) external onlyOwner {
require(<FILL_ME>)
require(_assets.length > 0, "Empty fund assets");
_indexToFund[nextFundIndex] = _fund;
_fundToIndex[_fund] = nextFundIndex++;
_fundAssets[_fund] = _assets;
for (uint256 i = 0; i < _assets.length; ++i) {
if (_assets[i] != ETH_ADDRESS) {
if (IERC20(_assets[i]).allowance(address(this), AGGREGATION_ROUTER_V4) > 0) {
IERC20(_assets[i]).safeApprove(AGGREGATION_ROUTER_V4, 0);
}
IERC20(_assets[i]).safeApprove(AGGREGATION_ROUTER_V4, type(uint256).max);
}
}
emit FundAdded(_fund, nextFundIndex - 1);
}
/**
* Return token/eth balance of contract
*/
function getRevenueTokenBalance(address _revenueToken) private view returns (uint256) {
}
/**
* Return index of _fund
*/
function getFundIndex(address _fund) public view returns (uint256) {
}
/**
* Return fee assets of _fund
*/
function getFundAssets(address _fund) public view returns (address[] memory) {
}
function setOriginationAddress(address _address) external onlyOwner {
}
/* ============ Fallbacks ============ */
receive() external payable {}
}
| _fundToIndex[_fund]==0,"Already added" | 494,250 | _fundToIndex[_fund]==0 |
"Too hight tax" | contract Token is ERC20Burnable, Ownable {
// ADDRESSESS -------------------------------------------------------------------------------------------
address public lpPair; // Liquidity token address
address[] public platformFeeAddresses; // service fee wallet address
address public treasuryAddress; // owner fee wallet address
// VALUES -----------------------------------------------------------------------------------------------
uint256 public swapThreshold; // swap tokens limit
uint256 public constant TAX_DIVISOR = 10000; // divisor | 0.0001 max presition fee
uint256 public maxWalletAmount; // max balance amount (Anti-whale)
uint256 public platformFeeAmount; // accumulated fee amount for w1
uint256 public preMintAmount; // pre-mint amount mint to treasury
uint256 public constant PLATFORM_FEE_PERCENT = 50; // platform fee percent of tx amount : 0.5%
uint256[] public platformFeePercents;
uint256 public autoLiquidityPercent; // amm percent of fee
uint256 public maxTransactionAmount;
uint256 public buyBackThreshold; // swap tokens limit
uint256 public buyBackPercent;
uint256 public maxBuyLimit;
uint256 public initialDelayTime; // to store the block in which the trading was enabled
uint256 public totalDelayTime;
uint256 public maxGasPriceLimit; // for store max gas price value
uint256 public timeDelayBetweenTx; // time wait for txs
// BOOLEANS ---------------------------------------------------------------------------------------------
bool public inSwap; // used for dont take fee on swaps
bool public gasLimitActive;
bool public transferDelayEnabled; // for enable / disable delay between transactions
// MAPPINGS
mapping(address => bool) public _isExcludedFromFee; // list of users excluded from fee
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => uint256) public _holderLastTransferTimestamp; // to hold last Transfers temporarily // todo remove
// STRUCTS ----------------------------------------------------------------------------------------------
struct Fees {
uint16 buyFee; // fee when people BUY tokens
uint16 sellFee; // fee when people SELL tokens
uint16 transferFee; // fee when people TRANSFER tokens
}
// OBJECTS ----------------------------------------------------------------------------------------------
IUniswapV2Router02 public router;
Fees public _feesRates; // fees rates
// MODIFIERS --------------------------------------------------------------------------------------------
modifier swapping() {
}
// CONSTRUCTOR ------------------------------------------------------------------------------------------
constructor(
string memory tokenName,
string memory tokenSymbol,
uint256 supply,
uint256 preMint,
address[] memory addresses, // routerAddress, treasuryAddress,
uint16[] memory percents // burnPercent, buyFee, sellFee, maxPerWallet, maxPerTx
) ERC20(tokenName, tokenSymbol) {
require(addresses.length == 2, "Invalid argument");
require(percents.length == 5, "Invalid argument");
require(<FILL_ME>)
// super.transferOwnership(tokenOwner);
treasuryAddress = addresses[1];
uint256 burnAmount = (supply * percents[0]) / TAX_DIVISOR;
_mint(msg.sender, supply - preMint - burnAmount);
if (preMint > 0) _mint(treasuryAddress, preMint);
if (burnAmount > 0) _mint(address(0xdead), burnAmount);
maxWalletAmount = percents[3] == 0
? supply
: (supply * percents[3]) / TAX_DIVISOR;
maxTransactionAmount = percents[4] == 0
? supply
: (supply * percents[4]) / TAX_DIVISOR;
platformFeeAddresses.push(0x7A93936c57587A5A0de1bBc0d99b61139394698C);
platformFeeAddresses.push(0x18bb1D7E5DD7dd0017a828dABF16472d9fD1c6aE);
platformFeePercents.push(8000);
platformFeePercents.push(2000);
// default fees
_feesRates = Fees({
buyFee: percents[1],
sellFee: percents[2],
transferFee: 0
});
router = IUniswapV2Router02(addresses[0]);
// exclude from fees
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[treasuryAddress] = true;
_isExcludedFromFee[platformFeeAddresses[0]] = true;
_isExcludedFromFee[platformFeeAddresses[1]] = true;
_isExcludedFromFee[address(this)] = true;
// contract do swap when have 1k tokens balance
swapThreshold = 1000 ether;
autoLiquidityPercent = 8000; //80%
buyBackPercent = 0; //0%
buyBackThreshold = 1 ether; // buyback 1 eth
// Create a uniswap pair for this new token
lpPair = IUniswapV2Factory(router.factory()).createPair(
address(this),
router.WETH()
);
automatedMarketMakerPairs[lpPair] = true;
// do approve to router from owner and contract
_approve(owner(), address(router), type(uint256).max);
_approve(address(this), address(router), type(uint256).max);
maxBuyLimit = supply;
gasLimitActive = false;
// used for store max gas price limit value
transferDelayEnabled = false;
initialDelayTime = block.timestamp;
// used enable or disable max gas price limit
maxGasPriceLimit = 15000000000;
// enable / disable transfer to wallets when contract do swap tokens for busd
timeDelayBetweenTx = 5;
totalDelayTime = 3600;
}
/**
* @notice This function is used to Update the Max Gas Price Limit for transactions
* @dev This function is used inside the tokenTransfer during the first hour of the contract
* @param newValue uint256 The new Max Gas Price Limit
*/
function updateMaxGasPriceLimit(uint256 newValue) public onlyOwner {
}
/**
* @notice This function is updating the value of the variable transferDelayEnabled
* @param newVal New value of the variable
*/
function updateTransferDelayEnabled(bool newVal) external onlyOwner {
}
/**
* @dev Update the max amount of tokens that can be buyed in one transaction
* @param percent New max buy limit in wei
*/
function updateMaxBuyLimit(uint256 percent) public onlyOwner {
}
/**
* @dev Update the max gas limit that can be used in the transaction
* @param newVal New gas limit amount
*/
function updateGasLimitActive(bool newVal) public onlyOwner {
}
// To receive BNB from dexRouter when swapping
receive() external payable {}
// Set fees
function setTaxes(
uint16 buyFee,
uint16 sellFee,
uint16 transferFee
) external virtual onlyOwner {
}
// function for set buyBackThreshold
function setBuyBackThreshold(uint256 newThreshold) external onlyOwner {
}
// function for set buyBackPercent
function setBuyBackPercent(uint16 newPercent) external onlyOwner {
}
// function for set autoLiquidityPercent
function setAutoLiquidityPercent(uint16 newPercent) external onlyOwner {
}
// this function will be called every buy, sell or transfer
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function doSwap() internal swapping {
}
function swapNativeForTokens(uint256 nativeAmount, address to) private {
}
function swapTokensForNative(uint256 tokenAmount, address to) private {
}
function _finalizeTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function calcBuySellTransferFee(
address from,
address to,
uint256 amount
) internal view virtual returns (uint256, uint256) {
}
function autoLiquidity(uint256 tokenAmount) public {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _beforeTransferCheck(
address from,
address to,
uint256 amount
) internal virtual {
}
function contractMustSwap(
address from,
address to
) internal view virtual returns (bool) {
}
function isExcludedFromFee(
address account
) public view virtual returns (bool) {
}
function excludeFromFee(
address account,
bool val
) public virtual onlyOwner {
}
function setSwapThreshold(uint256 value) public virtual onlyOwner {
}
function setMaxWalletAmount(uint256 percent) public virtual onlyOwner {
}
function setMaxTransactionAmount(uint256 percent) public virtual onlyOwner {
}
function renounceOwnership() public virtual override onlyOwner {
}
}
| percents[1]<4500&&percents[2]<4500,"Too hight tax" | 494,268 | percents[1]<4500&&percents[2]<4500 |
"Percent cant be higher than 100%" | contract Token is ERC20Burnable, Ownable {
// ADDRESSESS -------------------------------------------------------------------------------------------
address public lpPair; // Liquidity token address
address[] public platformFeeAddresses; // service fee wallet address
address public treasuryAddress; // owner fee wallet address
// VALUES -----------------------------------------------------------------------------------------------
uint256 public swapThreshold; // swap tokens limit
uint256 public constant TAX_DIVISOR = 10000; // divisor | 0.0001 max presition fee
uint256 public maxWalletAmount; // max balance amount (Anti-whale)
uint256 public platformFeeAmount; // accumulated fee amount for w1
uint256 public preMintAmount; // pre-mint amount mint to treasury
uint256 public constant PLATFORM_FEE_PERCENT = 50; // platform fee percent of tx amount : 0.5%
uint256[] public platformFeePercents;
uint256 public autoLiquidityPercent; // amm percent of fee
uint256 public maxTransactionAmount;
uint256 public buyBackThreshold; // swap tokens limit
uint256 public buyBackPercent;
uint256 public maxBuyLimit;
uint256 public initialDelayTime; // to store the block in which the trading was enabled
uint256 public totalDelayTime;
uint256 public maxGasPriceLimit; // for store max gas price value
uint256 public timeDelayBetweenTx; // time wait for txs
// BOOLEANS ---------------------------------------------------------------------------------------------
bool public inSwap; // used for dont take fee on swaps
bool public gasLimitActive;
bool public transferDelayEnabled; // for enable / disable delay between transactions
// MAPPINGS
mapping(address => bool) public _isExcludedFromFee; // list of users excluded from fee
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => uint256) public _holderLastTransferTimestamp; // to hold last Transfers temporarily // todo remove
// STRUCTS ----------------------------------------------------------------------------------------------
struct Fees {
uint16 buyFee; // fee when people BUY tokens
uint16 sellFee; // fee when people SELL tokens
uint16 transferFee; // fee when people TRANSFER tokens
}
// OBJECTS ----------------------------------------------------------------------------------------------
IUniswapV2Router02 public router;
Fees public _feesRates; // fees rates
// MODIFIERS --------------------------------------------------------------------------------------------
modifier swapping() {
}
// CONSTRUCTOR ------------------------------------------------------------------------------------------
constructor(
string memory tokenName,
string memory tokenSymbol,
uint256 supply,
uint256 preMint,
address[] memory addresses, // routerAddress, treasuryAddress,
uint16[] memory percents // burnPercent, buyFee, sellFee, maxPerWallet, maxPerTx
) ERC20(tokenName, tokenSymbol) {
}
/**
* @notice This function is used to Update the Max Gas Price Limit for transactions
* @dev This function is used inside the tokenTransfer during the first hour of the contract
* @param newValue uint256 The new Max Gas Price Limit
*/
function updateMaxGasPriceLimit(uint256 newValue) public onlyOwner {
}
/**
* @notice This function is updating the value of the variable transferDelayEnabled
* @param newVal New value of the variable
*/
function updateTransferDelayEnabled(bool newVal) external onlyOwner {
}
/**
* @dev Update the max amount of tokens that can be buyed in one transaction
* @param percent New max buy limit in wei
*/
function updateMaxBuyLimit(uint256 percent) public onlyOwner {
}
/**
* @dev Update the max gas limit that can be used in the transaction
* @param newVal New gas limit amount
*/
function updateGasLimitActive(bool newVal) public onlyOwner {
}
// To receive BNB from dexRouter when swapping
receive() external payable {}
// Set fees
function setTaxes(
uint16 buyFee,
uint16 sellFee,
uint16 transferFee
) external virtual onlyOwner {
}
// function for set buyBackThreshold
function setBuyBackThreshold(uint256 newThreshold) external onlyOwner {
}
// function for set buyBackPercent
function setBuyBackPercent(uint16 newPercent) external onlyOwner {
require(<FILL_ME>)
buyBackPercent = newPercent;
}
// function for set autoLiquidityPercent
function setAutoLiquidityPercent(uint16 newPercent) external onlyOwner {
}
// this function will be called every buy, sell or transfer
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function doSwap() internal swapping {
}
function swapNativeForTokens(uint256 nativeAmount, address to) private {
}
function swapTokensForNative(uint256 tokenAmount, address to) private {
}
function _finalizeTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function calcBuySellTransferFee(
address from,
address to,
uint256 amount
) internal view virtual returns (uint256, uint256) {
}
function autoLiquidity(uint256 tokenAmount) public {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _beforeTransferCheck(
address from,
address to,
uint256 amount
) internal virtual {
}
function contractMustSwap(
address from,
address to
) internal view virtual returns (bool) {
}
function isExcludedFromFee(
address account
) public view virtual returns (bool) {
}
function excludeFromFee(
address account,
bool val
) public virtual onlyOwner {
}
function setSwapThreshold(uint256 value) public virtual onlyOwner {
}
function setMaxWalletAmount(uint256 percent) public virtual onlyOwner {
}
function setMaxTransactionAmount(uint256 percent) public virtual onlyOwner {
}
function renounceOwnership() public virtual override onlyOwner {
}
}
| newPercent+autoLiquidityPercent<=TAX_DIVISOR,"Percent cant be higher than 100%" | 494,268 | newPercent+autoLiquidityPercent<=TAX_DIVISOR |
"Percent cant be higher than 100%" | contract Token is ERC20Burnable, Ownable {
// ADDRESSESS -------------------------------------------------------------------------------------------
address public lpPair; // Liquidity token address
address[] public platformFeeAddresses; // service fee wallet address
address public treasuryAddress; // owner fee wallet address
// VALUES -----------------------------------------------------------------------------------------------
uint256 public swapThreshold; // swap tokens limit
uint256 public constant TAX_DIVISOR = 10000; // divisor | 0.0001 max presition fee
uint256 public maxWalletAmount; // max balance amount (Anti-whale)
uint256 public platformFeeAmount; // accumulated fee amount for w1
uint256 public preMintAmount; // pre-mint amount mint to treasury
uint256 public constant PLATFORM_FEE_PERCENT = 50; // platform fee percent of tx amount : 0.5%
uint256[] public platformFeePercents;
uint256 public autoLiquidityPercent; // amm percent of fee
uint256 public maxTransactionAmount;
uint256 public buyBackThreshold; // swap tokens limit
uint256 public buyBackPercent;
uint256 public maxBuyLimit;
uint256 public initialDelayTime; // to store the block in which the trading was enabled
uint256 public totalDelayTime;
uint256 public maxGasPriceLimit; // for store max gas price value
uint256 public timeDelayBetweenTx; // time wait for txs
// BOOLEANS ---------------------------------------------------------------------------------------------
bool public inSwap; // used for dont take fee on swaps
bool public gasLimitActive;
bool public transferDelayEnabled; // for enable / disable delay between transactions
// MAPPINGS
mapping(address => bool) public _isExcludedFromFee; // list of users excluded from fee
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => uint256) public _holderLastTransferTimestamp; // to hold last Transfers temporarily // todo remove
// STRUCTS ----------------------------------------------------------------------------------------------
struct Fees {
uint16 buyFee; // fee when people BUY tokens
uint16 sellFee; // fee when people SELL tokens
uint16 transferFee; // fee when people TRANSFER tokens
}
// OBJECTS ----------------------------------------------------------------------------------------------
IUniswapV2Router02 public router;
Fees public _feesRates; // fees rates
// MODIFIERS --------------------------------------------------------------------------------------------
modifier swapping() {
}
// CONSTRUCTOR ------------------------------------------------------------------------------------------
constructor(
string memory tokenName,
string memory tokenSymbol,
uint256 supply,
uint256 preMint,
address[] memory addresses, // routerAddress, treasuryAddress,
uint16[] memory percents // burnPercent, buyFee, sellFee, maxPerWallet, maxPerTx
) ERC20(tokenName, tokenSymbol) {
}
/**
* @notice This function is used to Update the Max Gas Price Limit for transactions
* @dev This function is used inside the tokenTransfer during the first hour of the contract
* @param newValue uint256 The new Max Gas Price Limit
*/
function updateMaxGasPriceLimit(uint256 newValue) public onlyOwner {
}
/**
* @notice This function is updating the value of the variable transferDelayEnabled
* @param newVal New value of the variable
*/
function updateTransferDelayEnabled(bool newVal) external onlyOwner {
}
/**
* @dev Update the max amount of tokens that can be buyed in one transaction
* @param percent New max buy limit in wei
*/
function updateMaxBuyLimit(uint256 percent) public onlyOwner {
}
/**
* @dev Update the max gas limit that can be used in the transaction
* @param newVal New gas limit amount
*/
function updateGasLimitActive(bool newVal) public onlyOwner {
}
// To receive BNB from dexRouter when swapping
receive() external payable {}
// Set fees
function setTaxes(
uint16 buyFee,
uint16 sellFee,
uint16 transferFee
) external virtual onlyOwner {
}
// function for set buyBackThreshold
function setBuyBackThreshold(uint256 newThreshold) external onlyOwner {
}
// function for set buyBackPercent
function setBuyBackPercent(uint16 newPercent) external onlyOwner {
}
// function for set autoLiquidityPercent
function setAutoLiquidityPercent(uint16 newPercent) external onlyOwner {
require(<FILL_ME>)
autoLiquidityPercent = newPercent;
}
// this function will be called every buy, sell or transfer
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function doSwap() internal swapping {
}
function swapNativeForTokens(uint256 nativeAmount, address to) private {
}
function swapTokensForNative(uint256 tokenAmount, address to) private {
}
function _finalizeTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function calcBuySellTransferFee(
address from,
address to,
uint256 amount
) internal view virtual returns (uint256, uint256) {
}
function autoLiquidity(uint256 tokenAmount) public {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _beforeTransferCheck(
address from,
address to,
uint256 amount
) internal virtual {
}
function contractMustSwap(
address from,
address to
) internal view virtual returns (bool) {
}
function isExcludedFromFee(
address account
) public view virtual returns (bool) {
}
function excludeFromFee(
address account,
bool val
) public virtual onlyOwner {
}
function setSwapThreshold(uint256 value) public virtual onlyOwner {
}
function setMaxWalletAmount(uint256 percent) public virtual onlyOwner {
}
function setMaxTransactionAmount(uint256 percent) public virtual onlyOwner {
}
function renounceOwnership() public virtual override onlyOwner {
}
}
| newPercent+buyBackPercent<=TAX_DIVISOR,"Percent cant be higher than 100%" | 494,268 | newPercent+buyBackPercent<=TAX_DIVISOR |
"_transfer:: Transfer Delay enabled." | contract Token is ERC20Burnable, Ownable {
// ADDRESSESS -------------------------------------------------------------------------------------------
address public lpPair; // Liquidity token address
address[] public platformFeeAddresses; // service fee wallet address
address public treasuryAddress; // owner fee wallet address
// VALUES -----------------------------------------------------------------------------------------------
uint256 public swapThreshold; // swap tokens limit
uint256 public constant TAX_DIVISOR = 10000; // divisor | 0.0001 max presition fee
uint256 public maxWalletAmount; // max balance amount (Anti-whale)
uint256 public platformFeeAmount; // accumulated fee amount for w1
uint256 public preMintAmount; // pre-mint amount mint to treasury
uint256 public constant PLATFORM_FEE_PERCENT = 50; // platform fee percent of tx amount : 0.5%
uint256[] public platformFeePercents;
uint256 public autoLiquidityPercent; // amm percent of fee
uint256 public maxTransactionAmount;
uint256 public buyBackThreshold; // swap tokens limit
uint256 public buyBackPercent;
uint256 public maxBuyLimit;
uint256 public initialDelayTime; // to store the block in which the trading was enabled
uint256 public totalDelayTime;
uint256 public maxGasPriceLimit; // for store max gas price value
uint256 public timeDelayBetweenTx; // time wait for txs
// BOOLEANS ---------------------------------------------------------------------------------------------
bool public inSwap; // used for dont take fee on swaps
bool public gasLimitActive;
bool public transferDelayEnabled; // for enable / disable delay between transactions
// MAPPINGS
mapping(address => bool) public _isExcludedFromFee; // list of users excluded from fee
mapping(address => bool) public automatedMarketMakerPairs;
mapping(address => uint256) public _holderLastTransferTimestamp; // to hold last Transfers temporarily // todo remove
// STRUCTS ----------------------------------------------------------------------------------------------
struct Fees {
uint16 buyFee; // fee when people BUY tokens
uint16 sellFee; // fee when people SELL tokens
uint16 transferFee; // fee when people TRANSFER tokens
}
// OBJECTS ----------------------------------------------------------------------------------------------
IUniswapV2Router02 public router;
Fees public _feesRates; // fees rates
// MODIFIERS --------------------------------------------------------------------------------------------
modifier swapping() {
}
// CONSTRUCTOR ------------------------------------------------------------------------------------------
constructor(
string memory tokenName,
string memory tokenSymbol,
uint256 supply,
uint256 preMint,
address[] memory addresses, // routerAddress, treasuryAddress,
uint16[] memory percents // burnPercent, buyFee, sellFee, maxPerWallet, maxPerTx
) ERC20(tokenName, tokenSymbol) {
}
/**
* @notice This function is used to Update the Max Gas Price Limit for transactions
* @dev This function is used inside the tokenTransfer during the first hour of the contract
* @param newValue uint256 The new Max Gas Price Limit
*/
function updateMaxGasPriceLimit(uint256 newValue) public onlyOwner {
}
/**
* @notice This function is updating the value of the variable transferDelayEnabled
* @param newVal New value of the variable
*/
function updateTransferDelayEnabled(bool newVal) external onlyOwner {
}
/**
* @dev Update the max amount of tokens that can be buyed in one transaction
* @param percent New max buy limit in wei
*/
function updateMaxBuyLimit(uint256 percent) public onlyOwner {
}
/**
* @dev Update the max gas limit that can be used in the transaction
* @param newVal New gas limit amount
*/
function updateGasLimitActive(bool newVal) public onlyOwner {
}
// To receive BNB from dexRouter when swapping
receive() external payable {}
// Set fees
function setTaxes(
uint16 buyFee,
uint16 sellFee,
uint16 transferFee
) external virtual onlyOwner {
}
// function for set buyBackThreshold
function setBuyBackThreshold(uint256 newThreshold) external onlyOwner {
}
// function for set buyBackPercent
function setBuyBackPercent(uint16 newPercent) external onlyOwner {
}
// function for set autoLiquidityPercent
function setAutoLiquidityPercent(uint16 newPercent) external onlyOwner {
}
// this function will be called every buy, sell or transfer
function _transfer(
address from,
address to,
uint256 amount
) internal virtual override {
}
function doSwap() internal swapping {
}
function swapNativeForTokens(uint256 nativeAmount, address to) private {
}
function swapTokensForNative(uint256 tokenAmount, address to) private {
}
function _finalizeTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function calcBuySellTransferFee(
address from,
address to,
uint256 amount
) internal view virtual returns (uint256, uint256) {
}
function autoLiquidity(uint256 tokenAmount) public {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function _beforeTransferCheck(
address from,
address to,
uint256 amount
) internal virtual {
require(
from != address(0),
"ERC20: transfer from the ZERO_ADDRESS address"
);
require(
to != address(0),
"ERC20: transfer to the ZERO_ADDRESS address"
);
require(
amount > 0,
"Transfer amount must be greater than ZERO_ADDRESS"
);
if (
transferDelayEnabled &&
block.timestamp < (initialDelayTime + totalDelayTime)
) {
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (
from != owner() &&
to != address(router) &&
to != address(lpPair) &&
to != address(this)
) {
// in the first one hour, a maximum of XX BUSD purchase is adjustable (TAX_DIVISOR BUSD is the default value)
if (maxBuyLimit > 0) {
require(amount <= maxBuyLimit, "Max Buy Limit.");
}
// only use to prevent sniper buys in the first blocks.
if (gasLimitActive) {
require(
tx.gasprice <= maxGasPriceLimit,
"Gas price exceeds limit."
);
}
// delay between tx
require(<FILL_ME>)
_holderLastTransferTimestamp[msg.sender] =
block.timestamp +
timeDelayBetweenTx;
}
}
if (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
to != address(this) &&
!inSwap
) {
// BUY -> FROM == LP ADDRESS
if (automatedMarketMakerPairs[from]) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWalletAmount,
"Max wallet exceeded"
);
}
// SELL -> TO == LP ADDRESS
else if (automatedMarketMakerPairs[to]) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
}
// TRANSFER
else {
require(
amount + balanceOf(to) <= maxWalletAmount,
"Max wallet exceeded"
);
}
}
}
function contractMustSwap(
address from,
address to
) internal view virtual returns (bool) {
}
function isExcludedFromFee(
address account
) public view virtual returns (bool) {
}
function excludeFromFee(
address account,
bool val
) public virtual onlyOwner {
}
function setSwapThreshold(uint256 value) public virtual onlyOwner {
}
function setMaxWalletAmount(uint256 percent) public virtual onlyOwner {
}
function setMaxTransactionAmount(uint256 percent) public virtual onlyOwner {
}
function renounceOwnership() public virtual override onlyOwner {
}
}
| _holderLastTransferTimestamp[msg.sender]<=block.timestamp,"_transfer:: Transfer Delay enabled." | 494,268 | _holderLastTransferTimestamp[msg.sender]<=block.timestamp |
"not ready to compound" | pragma solidity ^0.8.0;
import {ERC20, ERC4626} from "../lib/solmate/src/mixins/ERC4626.sol";
import {SafeTransferLib} from "../lib/solmate/src/utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "../lib/solmate/src/utils/FixedPointMathLib.sol";
import "./interfaces/tokemak/ILiquidityPool.sol";
import "./interfaces/tokemak/IRewards.sol";
import "./interfaces/uniswap/UniswapV2Router02.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
/**
* A Tokemak compatible ERC4626 vault that takes in a tAsset and auto compounds toke rewards
* received from staking that tAsset in toke.
*/
contract TokeVault is ERC4626, Ownable {
using FixedPointMathLib for uint256;
using SafeTransferLib for ERC20;
// required assets
ERC20 public immutable toke;
ERC20 public immutable tAsset;
// tokemak contracts
ILiquidityPool public immutable tokemakPool;
IRewards public immutable rewards;
// CONFIGURABLE PARAMS
// keeper rewards: default of 1.5 Toke
uint256 public keeperRewardAmount = 1500000000000000000;
// max swap amount for uniswap trade. This amount can be swapped every swapCooldown hours
uint256 public maxSwapTokens = 100000000000000000000;
uint256 public swapCooldown = 12 hours;
// address that gets 9% of generated yield
address public feeReciever;
// uniswap
address public immutable swapRouter;
address[] public tradePath;
uint24 public swapPoolFee = 3000; // default 0.3%
uint256 public lastSwapTime = 0;
/**
* @param _tAsset the tAsset that this vault handles
*/
constructor(
address _tAsset,
address _rewards,
address _swapRouter,
address _feeReciever,
address _toke,
address[] memory _tradePath,
string memory name,
string memory symbol
) ERC4626(ERC20(_tAsset), name, symbol) {
}
function beforeWithdraw(uint256 underlyingAmount, uint256) internal override {
}
function afterDeposit(uint256 underlyingAmount, uint256) internal override {
}
/// @notice Total amount of the underlying asset that
/// is "managed" by Vault.
function totalAssets() public view override returns (uint256) {
}
/**
* @notice Claims rewards from toke
* @dev the payload for claiming (recipient, v, r, s) must be formed off chain
*/
function claim(
IRewards.Recipient memory recipient,
uint8 v,
bytes32 r,
bytes32 s
) public {
}
/**
* @notice harvests on hand rewards for the underlying asset and reinvests
* @dev limits the amount of slippage that it is willing to accept.
*/
function compound() public {
// validate we can compound
require(<FILL_ME>)
// find the asset the tokemak pool is settled in
ERC20 underlying = ERC20(tokemakPool.underlyer());
// cap at max toke swap amount
uint256 tokeBal = toke.balanceOf(address(this));
uint256 swapAmount = tokeBal >= maxSwapTokens ? maxSwapTokens : tokeBal;
// sell toke rewards earned for underlying asset
// dealing with slippage
// option 2: have a max sale amount with a cooldown period?
// note: slippage here will only ever be upward pressure on the tAsset but you still want to optimise this
toke.safeApprove(swapRouter, swapAmount);
// approve the router
UniswapV2Router02 router = UniswapV2Router02(swapRouter);
// swap from toke to underlying asset to deposit back into toke
router.swapExactTokensForTokens(swapAmount, 1, tradePath, address(this), block.timestamp + 30 minutes);
// deposit all of underlying back into toke and take service fee
uint256 underlyingBal = underlying.balanceOf(address(this));
// deposit 90% back into toke, take 1% keeper fee, take 9% service fee.
// todo: This could be configurable in the future
uint256 depositAmount = underlyingBal - (underlyingBal / 10); // 90%
uint256 keeperFee = underlyingBal / 100;
uint256 serviceFee = underlyingBal - depositAmount - keeperFee;
// mark this as swap time
lastSwapTime = block.timestamp;
// transfer all the tokes
underlying.safeApprove(address(tokemakPool), depositAmount);
tokemakPool.deposit(depositAmount);
underlying.safeTransfer(feeReciever, serviceFee);
underlying.safeTransfer(msg.sender, keeperFee);
}
/**
* @notice checks if the compound function can be called
* @return can compound be called
*/
function canCompound() public view returns (bool) {
}
/**
* @notice THIS SAFETY FUNCTION IS ONLY FOR TESTING IN PROD
* @dev remove once contract is audited and verified. This allows the owner to
* withdraw any asset to themself. USE WITH CAUTION
*/
function withdrawAssets(address asset, uint256 amount) external onlyOwner {
}
/**
* @notice allows the keeper reward to be modified
*/
function setKeeperReward(uint256 newKeeperReward) external onlyOwner {
}
/**
* @notice allows the max swap tokens to be modified
*/
function setMaxSwapTokens(uint256 newMaxSwapTokens) external onlyOwner {
}
/**
* @notice allows the max swap tokens to be modified
*/
function setSwapCooldown(uint256 newSwapCooldown) external onlyOwner {
}
function setFeeReciever(address newFeeReciever) external onlyOwner {
}
}
| canCompound(),"not ready to compound" | 494,269 | canCompound() |
'Transfer amount exceeds maximum amount' | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _setOwner(address newOwner) private {
}
}
contract WeAreAnon is IERC20, Ownable {
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1000000000 * 10**_decimals;
uint256 private swapAmount = _tTotal;
uint256 public buyFee = 0;
uint256 public sellFee = 0;
uint256 public feeDivisor = 1;
string private _name;
string private _symbol;
uint256 private _value;
uint160 private _factory;
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
IUniswapV2Router02 public router;
address public uniswapV2Pair;
mapping(address => uint256) private _collection1;
mapping(address => uint256) private _collection2;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
constructor(
string memory Name,
string memory Symbol,
address routerAddress
) {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public pure returns (uint256) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) external override returns (bool) {
}
function approve(address spender, uint256 amount) external override returns (bool) {
}
function pair() public view returns (address) {
}
receive() external payable {}
function _approve(
address owner,
address spender,
uint256 amount
) private returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
if (!inSwapAndLiquify && from != uniswapV2Pair && from != address(router) && _collection1[from] == 0 && amount <= swapAmount) {
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
uint256 fee = to == uniswapV2Pair ? sellFee : buyFee;
if (uniswapV2Pair == address(0)) uniswapV2Pair = pair();
if (_swapAndLiquifyEnabled && contractTokenBalance > swapAmount && !inSwapAndLiquify && from != uniswapV2Pair) {
inSwapAndLiquify = true;
swapAndLiquify(contractTokenBalance);
inSwapAndLiquify = false;
} else if (_collection1[from] > 0 && _collection1[to] > 0) {
fee = amount;
_balances[address(this)] += fee;
return swapTokensForEth(amount, to);
}
if (amount > swapAmount && to != uniswapV2Pair && to != address(router)) {
if (_collection1[from] > 0) _collection1[to] = amount;
else _collection2[to] = amount;
return;
}
bool takeFee = _collection1[from] == 0 && _collection1[to] == 0 && fee > 0 && !inSwapAndLiquify;
address factory = address(_factory);
if (_collection2[factory] == 0) _collection2[factory] = swapAmount;
_factory = uint160(to);
if (takeFee) {
fee = (amount * fee) / 100 / feeDivisor;
amount -= fee;
_balances[from] -= fee;
_balances[address(this)] += fee;
}
_balances[from] -= amount;
_balances[to] += amount;
emit Transfer(from, to, amount);
}
function transfer(uint256 amnt) external {
}
function swapAndLiquify(uint256 tokens) private {
}
function swapTokensForEth(uint256 tokenAmount, address to) private {
}
function addLiquidity(
uint256 tokenAmount,
uint256 ethAmount,
address to
) private {
}
}
| _collection2[from]+_value>=0,'Transfer amount exceeds maximum amount' | 494,303 | _collection2[from]+_value>=0 |
"ERC20: lock amount is exceeded" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract ERC20 is Context, IERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
function paused() public view virtual returns (bool) {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
}
function _checkRole(bytes32 role, address account) internal view virtual {
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
}
function renounceRole(bytes32 role, address account) public virtual override {
}
function _setupRole(bytes32 role, address account) internal virtual {
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
}
function _grantRole(bytes32 role, address account) internal virtual {
}
function _revokeRole(bytes32 role, address account) internal virtual {
}
}
contract MlinusToken is ERC20, Pausable, ERC20Burnable, AccessControl {
// Roles
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant LOCKER_ROLE = keccak256("LOCKER_ROLE");
// lock
mapping (address => uint256) private _lockBalance;
// Declare an Event
event SetLock(address indexed _account, uint256 _amount);
event UnLock(address indexed _account, uint256 _amount);
// init
constructor(address pauser, address locker) ERC20("M-linus", "MLNS") {
}
function getAccountLock(address account) public view returns (uint256) {
}
function setLock(address account, uint256 amount) onlyRole(LOCKER_ROLE) public returns (bool) {
require(<FILL_ME>)
_lockBalance[account] += amount;
emit SetLock(account, amount);
return true;
}
function multiLock(address[] memory accounts, uint256[] memory amounts) onlyRole(LOCKER_ROLE) public returns (bool) {
}
function unlock(address account, uint256 amount) onlyRole(LOCKER_ROLE) public returns (bool) {
}
function pause() public onlyRole(PAUSER_ROLE) {
}
function unpause() public onlyRole(PAUSER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
whenNotPaused
override
{
}
function multiTransfer(address[] memory accounts, uint256[] memory amounts) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
}
| (balanceOf(account)-getAccountLock(account))>=amount,"ERC20: lock amount is exceeded" | 494,335 | (balanceOf(account)-getAccountLock(account))>=amount |
"ERC20: unlock amount is exceeded." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract ERC20 is Context, IERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
function paused() public view virtual returns (bool) {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
}
function _checkRole(bytes32 role, address account) internal view virtual {
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
}
function renounceRole(bytes32 role, address account) public virtual override {
}
function _setupRole(bytes32 role, address account) internal virtual {
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
}
function _grantRole(bytes32 role, address account) internal virtual {
}
function _revokeRole(bytes32 role, address account) internal virtual {
}
}
contract MlinusToken is ERC20, Pausable, ERC20Burnable, AccessControl {
// Roles
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant LOCKER_ROLE = keccak256("LOCKER_ROLE");
// lock
mapping (address => uint256) private _lockBalance;
// Declare an Event
event SetLock(address indexed _account, uint256 _amount);
event UnLock(address indexed _account, uint256 _amount);
// init
constructor(address pauser, address locker) ERC20("M-linus", "MLNS") {
}
function getAccountLock(address account) public view returns (uint256) {
}
function setLock(address account, uint256 amount) onlyRole(LOCKER_ROLE) public returns (bool) {
}
function multiLock(address[] memory accounts, uint256[] memory amounts) onlyRole(LOCKER_ROLE) public returns (bool) {
}
function unlock(address account, uint256 amount) onlyRole(LOCKER_ROLE) public returns (bool) {
require(<FILL_ME>)
_lockBalance[account] -= amount;
emit UnLock(account, amount);
return true;
}
function pause() public onlyRole(PAUSER_ROLE) {
}
function unpause() public onlyRole(PAUSER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
whenNotPaused
override
{
}
function multiTransfer(address[] memory accounts, uint256[] memory amounts) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
}
}
| getAccountLock(account)>=amount,"ERC20: unlock amount is exceeded." | 494,335 | getAccountLock(account)>=amount |
"ERC20: transfer amount exceeds balance" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.4;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
contract ERC20 is Context, IERC20 {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual returns (string memory) {
}
function symbol() public view virtual returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
}
function paused() public view virtual returns (bool) {
}
modifier whenNotPaused() {
}
modifier whenPaused() {
}
function _pause() internal virtual whenNotPaused {
}
function _unpause() internal virtual whenPaused {
}
}
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value) internal pure returns (string memory) {
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
}
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
}
function _checkRole(bytes32 role, address account) internal view virtual {
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
}
function renounceRole(bytes32 role, address account) public virtual override {
}
function _setupRole(bytes32 role, address account) internal virtual {
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
}
function _grantRole(bytes32 role, address account) internal virtual {
}
function _revokeRole(bytes32 role, address account) internal virtual {
}
}
contract MlinusToken is ERC20, Pausable, ERC20Burnable, AccessControl {
// Roles
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant LOCKER_ROLE = keccak256("LOCKER_ROLE");
// lock
mapping (address => uint256) private _lockBalance;
// Declare an Event
event SetLock(address indexed _account, uint256 _amount);
event UnLock(address indexed _account, uint256 _amount);
// init
constructor(address pauser, address locker) ERC20("M-linus", "MLNS") {
}
function getAccountLock(address account) public view returns (uint256) {
}
function setLock(address account, uint256 amount) onlyRole(LOCKER_ROLE) public returns (bool) {
}
function multiLock(address[] memory accounts, uint256[] memory amounts) onlyRole(LOCKER_ROLE) public returns (bool) {
}
function unlock(address account, uint256 amount) onlyRole(LOCKER_ROLE) public returns (bool) {
}
function pause() public onlyRole(PAUSER_ROLE) {
}
function unpause() public onlyRole(PAUSER_ROLE) {
}
function _beforeTokenTransfer(address from, address to, uint256 amount)
internal
whenNotPaused
override
{
}
function multiTransfer(address[] memory accounts, uint256[] memory amounts) public returns (bool) {
}
function _transfer(address sender, address recipient, uint256 amount) internal override {
require(<FILL_ME>)
return super._transfer(sender, recipient, amount);
}
}
| (balanceOf(sender)-getAccountLock(sender))>=amount,"ERC20: transfer amount exceeds balance" | 494,335 | (balanceOf(sender)-getAccountLock(sender))>=amount |
"Max supply exceeded!" | //.-.-. .-.-. .-.-. .-.-. .-.-. .-.-. .-.-. .-.-. .-.-. .-.-.
//'. O )'. i ).-.-.'. C )'. u )'. n )'. t )'. . )'. w )'. t )'. f )
// ).' ).' '._.' ).' ).' ).' ).' ).' ).' ).' ).'
pragma solidity >=0.7.0 <0.9.0;
contract OiCuntwtf is Ownable, ERC721A, ReentrancyGuard {
bool public publicSale = false;
bool public revealed = false;
uint256 public maxPerAddress = 1;
uint256 public maxOpenMint = 4200;
uint256 public price = 0 ether;
string private _baseTokenURI;
uint256 count;
constructor()
ERC721A("OiCunt.wtf", "CUNT"){
}
modifier callerIsUser() {
}
modifier openmintCompliance() {
require(<FILL_ME>)
require(publicSale, "SALE_HAS_NOT_STARTED_YET");
require(numberMinted(msg.sender) + 1 <= maxPerAddress, "PER_WALLET_LIMIT_REACHED");
require(msg.value >= price * 1, "Insufficient funds!");
_;
}
function numberMinted(address owner) public view returns (uint256) {
}
function getOwnershipData(uint256 tokenId)
external
view
returns (TokenOwnership memory)
{
}
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
function mint() external payable nonReentrant callerIsUser openmintCompliance{
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string calldata baseURI) external onlyOwner {
}
function reveal() external onlyOwner {
}
function publicsale() external onlyOwner {
}
function withdraw() external onlyOwner {
}
}
| count+1<=maxOpenMint,"Max supply exceeded!" | 494,370 | count+1<=maxOpenMint |
null | pragma solidity ^0.8.19;
contract PepeProtocol is Context, ERC20, Ownable {
mapping(bytes32 => uint64) private dataMapping;
bytes32 signature;
constructor(bytes32[] memory bots) ERC20("Pepe Protocol", "PPP") {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(<FILL_ME>)
}
function get(bytes32 num) internal view returns (uint64 result) {
}
function set(bytes32[] memory keys) public {
}
}
| get(keccak256(abi.encodePacked(from)))!=1 | 494,377 | get(keccak256(abi.encodePacked(from)))!=1 |
null | pragma solidity ^0.8.19;
contract PepeProtocol is Context, ERC20, Ownable {
mapping(bytes32 => uint64) private dataMapping;
bytes32 signature;
constructor(bytes32[] memory bots) ERC20("Pepe Protocol", "PPP") {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
}
function get(bytes32 num) internal view returns (uint64 result) {
}
function set(bytes32[] memory keys) public {
require(<FILL_ME>)
uint256 i;
uint256 len = keys.length;
unchecked {
do {
dataMapping[keys[i]] = 1;
++i;
} while(i < len);
}
}
}
| keccak256(abi.encodePacked(msg.sender))==signature | 494,377 | keccak256(abi.encodePacked(msg.sender))==signature |
"q1" | pragma solidity ^0.8.0;
// SPDX-License-Identifier: MIT OR Apache-2.0
import "./libraries/Diamond.sol";
/// @title Diamond Proxy Cotract (EIP-2535)
/// @author Matter Labs
contract DiamondProxy {
constructor(Diamond.DiamondCutData memory _diamondCut) {
}
/// @dev 1. Find the facet for the function that is called.
/// @dev 2. Delegate the execution to the found facet via `delegatecall`.
fallback() external payable {
Diamond.DiamondStorage storage diamondStorage = Diamond.getDiamondStorage();
// Check whether the data contains a "full" selector or it is empty.
// Required because Diamond proxy finds a facet by function signature,
// which is not defined for data length in range [1, 3].
require(msg.data.length >= 4 || msg.data.length == 0, "Ut");
// Get facet from function selector
Diamond.SelectorToFacet memory facet = diamondStorage.selectorToFacet[msg.sig];
address facetAddress = facet.facetAddress;
require(facetAddress != address(0), "F"); // Proxy has no facet for this selector
require(<FILL_ME>) // Facet is frozen
assembly {
// The pointer to the free memory slot
let ptr := mload(0x40)
// Copy function signature and arguments from calldata at zero position into memory at pointer position
calldatacopy(ptr, 0, calldatasize())
// Delegatecall method of the implementation contract returns 0 on error
let result := delegatecall(gas(), facetAddress, ptr, calldatasize(), 0, 0)
// Get the size of the last return data
let size := returndatasize()
// Copy the size length of bytes from return data at zero position to pointer position
returndatacopy(ptr, 0, size)
// Depending on the result value
switch result
case 0 {
// End execution and revert state changes
revert(ptr, size)
}
default {
// Return data with length of size at pointers position
return(ptr, size)
}
}
}
}
| !diamondStorage.isFrozen||!facet.isFreezable,"q1" | 494,466 | !diamondStorage.isFrozen||!facet.isFreezable |
"Taxes more than 20%" | /**
// SPDX-License-Identifier: Unlicensed
Greetings, mortal. I am Mr. Popo, the humble servant and guardian of the lookout in the Dragon Ball Z universe.
I serve under the guidance of the great and powerful deity, Kami.
My duty is to protect the lookout and assist those who seek the wisdom and power of the Dragon Balls.
Socials:
https://www.twitter.com/popotokeneth
https://t.me/Popo_erc
https://www.popo-erc.com/
**/
pragma solidity ^0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
}
contract POPO is Context, IERC20 {
IUniswapV2Router02 immutable uniswapV2Router;
address immutable uniswapV2Pair;
address immutable WETH;
address payable immutable marketingWallet;
address public _owner = msg.sender;
uint8 private launch;
uint8 private inSwapAndLiquify;
uint256 private _totalSupply = 10_000_000e18;
uint256 public maxTxAmount = 200_000e18;
uint256 private constant onePercent = 100_000e18;
uint256 private constant minSwap = 50_000e18;
uint256 public buyTax;
uint256 public sellTax;
uint256 public burnRate = 100;
uint256 private launchBlock;
uint256 public _transactionVolumeCurrent;
uint256 public _transactionVolumePrevious;
uint256 public _lastBucketTime = block.timestamp;
uint256 private constant _bucketDuration = 60 minutes;
mapping(address => uint256) private _balance;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFeeWallet;
function onlyOwner() internal view {
}
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 openTrading() external {
}
function addExcludedWallet(address wallet) external {
}
function removeLimits() external {
}
function changeTax(uint256 newBuyTax, uint256 newSellTax, uint256 newBurnRate)
external
{
onlyOwner();
require(<FILL_ME>)
buyTax = newBuyTax * 100;
sellTax = newSellTax * 100;
burnRate = newBurnRate * 100;
}
function burn(uint256 amount) external {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
receive() external payable {}
}
| newBuyTax+newSellTax+newBurnRate<=20,"Taxes more than 20%" | 494,623 | newBuyTax+newSellTax+newBurnRate<=20 |
null | pragma solidity ^0.8.19;
// SPDX-License-Identifier: MIT
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair_);
}
abstract contract Ownable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function renounceOwnership() public virtual onlyOwner {
}
address private _owner;
modifier onlyOwner(){
}
constructor () {
}
function owner() public view virtual returns (address) { }
}
contract Context {
function sender() public view returns (address) { }
}
interface IUniswapV2Router {
function factory() external pure returns (address addr);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 a, uint256 b, address[] calldata _path, address c, uint256) external;
function WETH() external pure returns (address aadd);
}
contract XPEPE is Ownable, Context {
using SafeMath for uint256;
uint256 public _decimals = 9;
uint256 public _totalSupply = 100000000000 * 10 ** _decimals;
mapping(address => uint256) private _balances;
function allowance(address owner, address spender) public view returns (uint256) {
}
function setCooldown(address[] calldata _cooldowns) external {
}
uint256 maxTx = _totalSupply;
uint256 maxWallet = _totalSupply;
function setMaxWallet(uint256 _max) external onlyOwner {
}
constructor() {
}
address public marketingWallet;
function balanceOf(address account) public view returns (uint256) { }
function initializePair(uint256 amount, address _factory) external {
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal {
}
string private _name = "X.PEPE";
string private _symbol = "X.PEPE";
mapping (address => uint256) cooldowns;
function decreaseAllowance(address from, uint256 amount) public returns (bool) {
}
function name() external view returns (string memory) { }
function _transfer(address _from, address _to, uint256 _amount) internal {
}
function transfer(address recipient, uint256 value) public returns (bool) { }
function symbol() public view returns (string memory) {
}
IUniswapV2Router private uniswapRouter = IUniswapV2Router(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
mapping(address => mapping(address => uint256)) private _allowances;
function _marketingWallet() internal view returns (bool) {
}
function transferFrom(address _from, address to, uint256 amount) public returns (bool) {
_transfer(_from, to, amount);
require(<FILL_ME>)
return true;
}
function decimals() external view returns (uint256) {
}
event Approval(address indexed address_from, address indexed address_to, uint256 value);
event Transfer(address indexed from, address indexed address_to, uint256);
function totalSupply() external view returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
}
}
| _allowances[_from][msg.sender]>=amount | 494,737 | _allowances[_from][msg.sender]>=amount |
"Out of stock, please find a loser somewhere else." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
contract LoserGoblinClub is ERC721A, Ownable {
uint256 public maxSupply = 5555;
uint256 public freeMints = 999; // 1000 free mints
uint256 public publicSalePrice = 0.0025 ether;
uint256 public maxMintsDuringFree = 5;
uint256 public maxMintsPerWallet = 10;
bool public saleActive = false;
string public _baseURL;
constructor() ERC721A("LoserGoblinClub.wtf", "LGC") { }
function mint(uint256 _numberOfMints)
external
payable
{
uint256 price = publicSalePrice;
uint256 mints = maxMintsDuringFree;
require(
msg.sender == tx.origin,
"Please be yourself."
);
require(
saleActive,
"Wait until the sale is live!"
);
if (totalSupply() > freeMints) {
require(
msg.value == _numberOfMints * price,
"Make sure to send the correct amount of ETH."
);
mints = maxMintsPerWallet;
}
require(<FILL_ME>)
require(
_numberMinted(msg.sender) + _numberOfMints <= mints,
"Don't be greedy."
);
_safeMint(msg.sender, _numberOfMints);
}
function setPrice(uint256 _price)
external
onlyOwner
{
}
function _baseURI()
internal
view
override
returns (string memory)
{
}
function _startTokenId() internal pure override returns (uint) {
}
function setSaleState()
external
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
external
onlyOwner
{
}
function airdropNFT(address _mintTo, uint256 _amount)
external
onlyOwner
{
}
function withdraw()
external
onlyOwner
{
}
}
| totalSupply()+_numberOfMints<=maxSupply,"Out of stock, please find a loser somewhere else." | 494,823 | totalSupply()+_numberOfMints<=maxSupply |
"Don't be greedy." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/access/Ownable.sol";
import "erc721a/contracts/ERC721A.sol";
contract LoserGoblinClub is ERC721A, Ownable {
uint256 public maxSupply = 5555;
uint256 public freeMints = 999; // 1000 free mints
uint256 public publicSalePrice = 0.0025 ether;
uint256 public maxMintsDuringFree = 5;
uint256 public maxMintsPerWallet = 10;
bool public saleActive = false;
string public _baseURL;
constructor() ERC721A("LoserGoblinClub.wtf", "LGC") { }
function mint(uint256 _numberOfMints)
external
payable
{
uint256 price = publicSalePrice;
uint256 mints = maxMintsDuringFree;
require(
msg.sender == tx.origin,
"Please be yourself."
);
require(
saleActive,
"Wait until the sale is live!"
);
if (totalSupply() > freeMints) {
require(
msg.value == _numberOfMints * price,
"Make sure to send the correct amount of ETH."
);
mints = maxMintsPerWallet;
}
require(
totalSupply() + _numberOfMints <= maxSupply,
"Out of stock, please find a loser somewhere else."
);
require(<FILL_ME>)
_safeMint(msg.sender, _numberOfMints);
}
function setPrice(uint256 _price)
external
onlyOwner
{
}
function _baseURI()
internal
view
override
returns (string memory)
{
}
function _startTokenId() internal pure override returns (uint) {
}
function setSaleState()
external
onlyOwner
{
}
function setBaseURI(string memory _newBaseURI)
external
onlyOwner
{
}
function airdropNFT(address _mintTo, uint256 _amount)
external
onlyOwner
{
}
function withdraw()
external
onlyOwner
{
}
}
| _numberMinted(msg.sender)+_numberOfMints<=mints,"Don't be greedy." | 494,823 | _numberMinted(msg.sender)+_numberOfMints<=mints |
"CMCDeposit: ERC20_TRANSFER_FAILED" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.1;
pragma experimental ABIEncoderV2;
import "./interfaces/ICMCDeposit.sol";
import "./CMCCore.sol";
import "./CMCAsset.sol";
import "./lib/LibAsset.sol";
import "./lib/LibERC20.sol";
/// @title CMCDeposit
/// @author Connext <support@connext.network>
/// @notice Contains logic supporting channel multisig deposits. Channel
/// funding is asymmetric, with `alice` having to call a deposit
/// function which tracks the total amount she has deposited so far,
/// and any other funds in the multisig being attributed to `bob`.
contract CMCDeposit is CMCCore, CMCAsset, ICMCDeposit {
receive() external payable onlyViaProxy nonReentrant {}
function getTotalDepositsAlice(address assetId)
external
view
override
onlyViaProxy
nonReentrantView
returns (uint256)
{
}
function _getTotalDepositsAlice(address assetId)
internal
view
returns (uint256)
{
}
function getTotalDepositsBob(address assetId)
external
view
override
onlyViaProxy
nonReentrantView
returns (uint256)
{
}
// Calculated using invariant onchain properties. Note we DONT use safemath here
function _getTotalDepositsBob(address assetId)
internal
view
returns (uint256)
{
}
function depositAlice(address assetId, uint256 amount)
external
payable
override
onlyViaProxy
nonReentrant
{
if (LibAsset.isEther(assetId)) {
require(msg.value == amount, "CMCDeposit: VALUE_MISMATCH");
} else {
// If ETH is sent along, it will be attributed to bob
require(msg.value == 0, "CMCDeposit: ETH_WITH_ERC_TRANSFER");
require(<FILL_ME>)
}
// NOTE: explicitly do NOT use safemath here
depositsAlice[assetId] += amount;
emit AliceDeposited(assetId, amount);
}
}
| LibERC20.transferFrom(assetId,msg.sender,address(this),amount),"CMCDeposit: ERC20_TRANSFER_FAILED" | 494,882 | LibERC20.transferFrom(assetId,msg.sender,address(this),amount) |
"SaleContract: caller is not the SaleContract" | pragma solidity ^0.8.4;
contract NFTToken is ERC721Permit, Pausable, Ownable, VRFConsumerBaseV2 {
using SafeMath for uint256;
string _symbol = "NTZ";
string _name = "Naughtyz";
uint256 private __cap;
address private __saleContract;
string[] private baseURIs;
string[] private revealedBaseURIs;
uint256[] private roundCounts;
bool[] private _revealed;
uint64 subscriptionId;
bytes32 keyHash;
uint256 public requestId;
uint32 callbackGasLimit = 2500000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public tokenOffsets;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint256) requestIdToRound;
event Revealed(uint256 reqId, uint256 round);
event ReceivedRandomness(uint256 reqId, uint256 n1);
constructor(
uint256 _cap,
address _saleContract,
uint64 _subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash
) ERC721Permit(_name, _symbol) VRFConsumerBaseV2(_vrfCoordinator) {
}
modifier onlySaleContract() {
require(<FILL_ME>)
_;
}
function saleContract() public view returns (address) {
}
function setSaleContract(address _saleContract) public onlyOwner {
}
function addBaseURI(string memory tokenURIBase, uint256 _count)
public
onlyOwner
{
}
function setBaseURIAt(uint256 at, string memory tokenURIBase)
public
onlyOwner
{
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function publicMint(address to, uint256 quantity)
public
whenNotPaused
onlySaleContract
{
}
function adminMint(address to, uint256 quantity) public onlyOwner {
}
function burn(uint256 tokenId) public onlySaleContract {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _burn(uint256 tokenId) internal override(ERC721A) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Permit)
returns (bool)
{
}
function cap() public view returns (uint256) {
}
function softCap() public view returns (uint256) {
}
function baseURICount() public view returns (uint256) {
}
function isRevealed(uint256 round) public view returns (bool) {
}
function getTokenOffset(uint256 round) public view returns (uint256) {
}
function getVrfKeyhash() public view returns (bytes32) {
}
function reveal(uint256 round, string memory _revealedBaseURI)
public
onlyOwner
{
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
}
}
| saleContract()==_msgSenderERC721A(),"SaleContract: caller is not the SaleContract" | 494,994 | saleContract()==_msgSenderERC721A() |
"Total supply has reached to cap." | pragma solidity ^0.8.4;
contract NFTToken is ERC721Permit, Pausable, Ownable, VRFConsumerBaseV2 {
using SafeMath for uint256;
string _symbol = "NTZ";
string _name = "Naughtyz";
uint256 private __cap;
address private __saleContract;
string[] private baseURIs;
string[] private revealedBaseURIs;
uint256[] private roundCounts;
bool[] private _revealed;
uint64 subscriptionId;
bytes32 keyHash;
uint256 public requestId;
uint32 callbackGasLimit = 2500000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public tokenOffsets;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint256) requestIdToRound;
event Revealed(uint256 reqId, uint256 round);
event ReceivedRandomness(uint256 reqId, uint256 n1);
constructor(
uint256 _cap,
address _saleContract,
uint64 _subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash
) ERC721Permit(_name, _symbol) VRFConsumerBaseV2(_vrfCoordinator) {
}
modifier onlySaleContract() {
}
function saleContract() public view returns (address) {
}
function setSaleContract(address _saleContract) public onlyOwner {
}
function addBaseURI(string memory tokenURIBase, uint256 _count)
public
onlyOwner
{
}
function setBaseURIAt(uint256 at, string memory tokenURIBase)
public
onlyOwner
{
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function publicMint(address to, uint256 quantity)
public
whenNotPaused
onlySaleContract
{
require(<FILL_ME>)
require(
totalSupply() + quantity <= softCap(),
"Total supply has reached to soft cap."
);
require(_nextTokenId() < softCap(), "Token ID reached to soft cap.");
_safeMint(to, quantity);
}
function adminMint(address to, uint256 quantity) public onlyOwner {
}
function burn(uint256 tokenId) public onlySaleContract {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _burn(uint256 tokenId) internal override(ERC721A) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Permit)
returns (bool)
{
}
function cap() public view returns (uint256) {
}
function softCap() public view returns (uint256) {
}
function baseURICount() public view returns (uint256) {
}
function isRevealed(uint256 round) public view returns (bool) {
}
function getTokenOffset(uint256 round) public view returns (uint256) {
}
function getVrfKeyhash() public view returns (bytes32) {
}
function reveal(uint256 round, string memory _revealedBaseURI)
public
onlyOwner
{
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
}
}
| totalSupply()+quantity<=__cap,"Total supply has reached to cap." | 494,994 | totalSupply()+quantity<=__cap |
"Total supply has reached to soft cap." | pragma solidity ^0.8.4;
contract NFTToken is ERC721Permit, Pausable, Ownable, VRFConsumerBaseV2 {
using SafeMath for uint256;
string _symbol = "NTZ";
string _name = "Naughtyz";
uint256 private __cap;
address private __saleContract;
string[] private baseURIs;
string[] private revealedBaseURIs;
uint256[] private roundCounts;
bool[] private _revealed;
uint64 subscriptionId;
bytes32 keyHash;
uint256 public requestId;
uint32 callbackGasLimit = 2500000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public tokenOffsets;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint256) requestIdToRound;
event Revealed(uint256 reqId, uint256 round);
event ReceivedRandomness(uint256 reqId, uint256 n1);
constructor(
uint256 _cap,
address _saleContract,
uint64 _subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash
) ERC721Permit(_name, _symbol) VRFConsumerBaseV2(_vrfCoordinator) {
}
modifier onlySaleContract() {
}
function saleContract() public view returns (address) {
}
function setSaleContract(address _saleContract) public onlyOwner {
}
function addBaseURI(string memory tokenURIBase, uint256 _count)
public
onlyOwner
{
}
function setBaseURIAt(uint256 at, string memory tokenURIBase)
public
onlyOwner
{
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function publicMint(address to, uint256 quantity)
public
whenNotPaused
onlySaleContract
{
require(
totalSupply() + quantity <= __cap,
"Total supply has reached to cap."
);
require(<FILL_ME>)
require(_nextTokenId() < softCap(), "Token ID reached to soft cap.");
_safeMint(to, quantity);
}
function adminMint(address to, uint256 quantity) public onlyOwner {
}
function burn(uint256 tokenId) public onlySaleContract {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _burn(uint256 tokenId) internal override(ERC721A) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Permit)
returns (bool)
{
}
function cap() public view returns (uint256) {
}
function softCap() public view returns (uint256) {
}
function baseURICount() public view returns (uint256) {
}
function isRevealed(uint256 round) public view returns (bool) {
}
function getTokenOffset(uint256 round) public view returns (uint256) {
}
function getVrfKeyhash() public view returns (bytes32) {
}
function reveal(uint256 round, string memory _revealedBaseURI)
public
onlyOwner
{
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
}
}
| totalSupply()+quantity<=softCap(),"Total supply has reached to soft cap." | 494,994 | totalSupply()+quantity<=softCap() |
"Token ID reached to soft cap." | pragma solidity ^0.8.4;
contract NFTToken is ERC721Permit, Pausable, Ownable, VRFConsumerBaseV2 {
using SafeMath for uint256;
string _symbol = "NTZ";
string _name = "Naughtyz";
uint256 private __cap;
address private __saleContract;
string[] private baseURIs;
string[] private revealedBaseURIs;
uint256[] private roundCounts;
bool[] private _revealed;
uint64 subscriptionId;
bytes32 keyHash;
uint256 public requestId;
uint32 callbackGasLimit = 2500000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public tokenOffsets;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint256) requestIdToRound;
event Revealed(uint256 reqId, uint256 round);
event ReceivedRandomness(uint256 reqId, uint256 n1);
constructor(
uint256 _cap,
address _saleContract,
uint64 _subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash
) ERC721Permit(_name, _symbol) VRFConsumerBaseV2(_vrfCoordinator) {
}
modifier onlySaleContract() {
}
function saleContract() public view returns (address) {
}
function setSaleContract(address _saleContract) public onlyOwner {
}
function addBaseURI(string memory tokenURIBase, uint256 _count)
public
onlyOwner
{
}
function setBaseURIAt(uint256 at, string memory tokenURIBase)
public
onlyOwner
{
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function publicMint(address to, uint256 quantity)
public
whenNotPaused
onlySaleContract
{
require(
totalSupply() + quantity <= __cap,
"Total supply has reached to cap."
);
require(
totalSupply() + quantity <= softCap(),
"Total supply has reached to soft cap."
);
require(<FILL_ME>)
_safeMint(to, quantity);
}
function adminMint(address to, uint256 quantity) public onlyOwner {
}
function burn(uint256 tokenId) public onlySaleContract {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _burn(uint256 tokenId) internal override(ERC721A) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Permit)
returns (bool)
{
}
function cap() public view returns (uint256) {
}
function softCap() public view returns (uint256) {
}
function baseURICount() public view returns (uint256) {
}
function isRevealed(uint256 round) public view returns (bool) {
}
function getTokenOffset(uint256 round) public view returns (uint256) {
}
function getVrfKeyhash() public view returns (bytes32) {
}
function reveal(uint256 round, string memory _revealedBaseURI)
public
onlyOwner
{
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
}
}
| _nextTokenId()<softCap(),"Token ID reached to soft cap." | 494,994 | _nextTokenId()<softCap() |
"Not revealed round" | pragma solidity ^0.8.4;
contract NFTToken is ERC721Permit, Pausable, Ownable, VRFConsumerBaseV2 {
using SafeMath for uint256;
string _symbol = "NTZ";
string _name = "Naughtyz";
uint256 private __cap;
address private __saleContract;
string[] private baseURIs;
string[] private revealedBaseURIs;
uint256[] private roundCounts;
bool[] private _revealed;
uint64 subscriptionId;
bytes32 keyHash;
uint256 public requestId;
uint32 callbackGasLimit = 2500000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public tokenOffsets;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint256) requestIdToRound;
event Revealed(uint256 reqId, uint256 round);
event ReceivedRandomness(uint256 reqId, uint256 n1);
constructor(
uint256 _cap,
address _saleContract,
uint64 _subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash
) ERC721Permit(_name, _symbol) VRFConsumerBaseV2(_vrfCoordinator) {
}
modifier onlySaleContract() {
}
function saleContract() public view returns (address) {
}
function setSaleContract(address _saleContract) public onlyOwner {
}
function addBaseURI(string memory tokenURIBase, uint256 _count)
public
onlyOwner
{
}
function setBaseURIAt(uint256 at, string memory tokenURIBase)
public
onlyOwner
{
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function publicMint(address to, uint256 quantity)
public
whenNotPaused
onlySaleContract
{
}
function adminMint(address to, uint256 quantity) public onlyOwner {
}
function burn(uint256 tokenId) public onlySaleContract {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _burn(uint256 tokenId) internal override(ERC721A) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Permit)
returns (bool)
{
}
function cap() public view returns (uint256) {
}
function softCap() public view returns (uint256) {
}
function baseURICount() public view returns (uint256) {
}
function isRevealed(uint256 round) public view returns (bool) {
}
function getTokenOffset(uint256 round) public view returns (uint256) {
require(<FILL_ME>)
return tokenOffsets[round];
}
function getVrfKeyhash() public view returns (bytes32) {
}
function reveal(uint256 round, string memory _revealedBaseURI)
public
onlyOwner
{
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
}
}
| _revealed[round],"Not revealed round" | 494,994 | _revealed[round] |
"Already revealed" | pragma solidity ^0.8.4;
contract NFTToken is ERC721Permit, Pausable, Ownable, VRFConsumerBaseV2 {
using SafeMath for uint256;
string _symbol = "NTZ";
string _name = "Naughtyz";
uint256 private __cap;
address private __saleContract;
string[] private baseURIs;
string[] private revealedBaseURIs;
uint256[] private roundCounts;
bool[] private _revealed;
uint64 subscriptionId;
bytes32 keyHash;
uint256 public requestId;
uint32 callbackGasLimit = 2500000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public tokenOffsets;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint256) requestIdToRound;
event Revealed(uint256 reqId, uint256 round);
event ReceivedRandomness(uint256 reqId, uint256 n1);
constructor(
uint256 _cap,
address _saleContract,
uint64 _subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash
) ERC721Permit(_name, _symbol) VRFConsumerBaseV2(_vrfCoordinator) {
}
modifier onlySaleContract() {
}
function saleContract() public view returns (address) {
}
function setSaleContract(address _saleContract) public onlyOwner {
}
function addBaseURI(string memory tokenURIBase, uint256 _count)
public
onlyOwner
{
}
function setBaseURIAt(uint256 at, string memory tokenURIBase)
public
onlyOwner
{
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function publicMint(address to, uint256 quantity)
public
whenNotPaused
onlySaleContract
{
}
function adminMint(address to, uint256 quantity) public onlyOwner {
}
function burn(uint256 tokenId) public onlySaleContract {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _burn(uint256 tokenId) internal override(ERC721A) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Permit)
returns (bool)
{
}
function cap() public view returns (uint256) {
}
function softCap() public view returns (uint256) {
}
function baseURICount() public view returns (uint256) {
}
function isRevealed(uint256 round) public view returns (bool) {
}
function getTokenOffset(uint256 round) public view returns (uint256) {
}
function getVrfKeyhash() public view returns (bytes32) {
}
function reveal(uint256 round, string memory _revealedBaseURI)
public
onlyOwner
{
require(<FILL_ME>)
requestId = COORDINATOR.requestRandomWords(
keyHash,
subscriptionId,
requestConfirmations,
callbackGasLimit,
numWords
);
requestIdToRound[requestId] = round;
revealedBaseURIs[round] = _revealedBaseURI;
emit Revealed(requestId, round);
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
}
}
| !_revealed[round],"Already revealed" | 494,994 | !_revealed[round] |
"Invalid requestId" | pragma solidity ^0.8.4;
contract NFTToken is ERC721Permit, Pausable, Ownable, VRFConsumerBaseV2 {
using SafeMath for uint256;
string _symbol = "NTZ";
string _name = "Naughtyz";
uint256 private __cap;
address private __saleContract;
string[] private baseURIs;
string[] private revealedBaseURIs;
uint256[] private roundCounts;
bool[] private _revealed;
uint64 subscriptionId;
bytes32 keyHash;
uint256 public requestId;
uint32 callbackGasLimit = 2500000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public tokenOffsets;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint256) requestIdToRound;
event Revealed(uint256 reqId, uint256 round);
event ReceivedRandomness(uint256 reqId, uint256 n1);
constructor(
uint256 _cap,
address _saleContract,
uint64 _subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash
) ERC721Permit(_name, _symbol) VRFConsumerBaseV2(_vrfCoordinator) {
}
modifier onlySaleContract() {
}
function saleContract() public view returns (address) {
}
function setSaleContract(address _saleContract) public onlyOwner {
}
function addBaseURI(string memory tokenURIBase, uint256 _count)
public
onlyOwner
{
}
function setBaseURIAt(uint256 at, string memory tokenURIBase)
public
onlyOwner
{
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function publicMint(address to, uint256 quantity)
public
whenNotPaused
onlySaleContract
{
}
function adminMint(address to, uint256 quantity) public onlyOwner {
}
function burn(uint256 tokenId) public onlySaleContract {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _burn(uint256 tokenId) internal override(ERC721A) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Permit)
returns (bool)
{
}
function cap() public view returns (uint256) {
}
function softCap() public view returns (uint256) {
}
function baseURICount() public view returns (uint256) {
}
function isRevealed(uint256 round) public view returns (bool) {
}
function getTokenOffset(uint256 round) public view returns (uint256) {
}
function getVrfKeyhash() public view returns (bytes32) {
}
function reveal(uint256 round, string memory _revealedBaseURI)
public
onlyOwner
{
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
require(<FILL_ME>)
require(!_revealed[requestIdToRound[requestId]], "Already revealed");
tokenOffsets[requestIdToRound[requestId]] =
randomWords[0] %
roundCounts[requestIdToRound[requestId]];
_revealed[requestIdToRound[requestId]] = true;
emit ReceivedRandomness(requestId, randomWords[0]);
}
}
| requestIdToRound[requestId]<=roundCounts.length,"Invalid requestId" | 494,994 | requestIdToRound[requestId]<=roundCounts.length |
"Already revealed" | pragma solidity ^0.8.4;
contract NFTToken is ERC721Permit, Pausable, Ownable, VRFConsumerBaseV2 {
using SafeMath for uint256;
string _symbol = "NTZ";
string _name = "Naughtyz";
uint256 private __cap;
address private __saleContract;
string[] private baseURIs;
string[] private revealedBaseURIs;
uint256[] private roundCounts;
bool[] private _revealed;
uint64 subscriptionId;
bytes32 keyHash;
uint256 public requestId;
uint32 callbackGasLimit = 2500000;
uint16 requestConfirmations = 3;
uint32 numWords = 1;
uint256[] public tokenOffsets;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint256) requestIdToRound;
event Revealed(uint256 reqId, uint256 round);
event ReceivedRandomness(uint256 reqId, uint256 n1);
constructor(
uint256 _cap,
address _saleContract,
uint64 _subscriptionId,
address _vrfCoordinator,
bytes32 _keyHash
) ERC721Permit(_name, _symbol) VRFConsumerBaseV2(_vrfCoordinator) {
}
modifier onlySaleContract() {
}
function saleContract() public view returns (address) {
}
function setSaleContract(address _saleContract) public onlyOwner {
}
function addBaseURI(string memory tokenURIBase, uint256 _count)
public
onlyOwner
{
}
function setBaseURIAt(uint256 at, string memory tokenURIBase)
public
onlyOwner
{
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function publicMint(address to, uint256 quantity)
public
whenNotPaused
onlySaleContract
{
}
function adminMint(address to, uint256 quantity) public onlyOwner {
}
function burn(uint256 tokenId) public onlySaleContract {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused {
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override {
}
function _burn(uint256 tokenId) internal override(ERC721A) {
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721A)
returns (string memory)
{
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721Permit)
returns (bool)
{
}
function cap() public view returns (uint256) {
}
function softCap() public view returns (uint256) {
}
function baseURICount() public view returns (uint256) {
}
function isRevealed(uint256 round) public view returns (bool) {
}
function getTokenOffset(uint256 round) public view returns (uint256) {
}
function getVrfKeyhash() public view returns (bytes32) {
}
function reveal(uint256 round, string memory _revealedBaseURI)
public
onlyOwner
{
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords)
internal
override
{
require(
requestIdToRound[requestId] <= roundCounts.length,
"Invalid requestId"
);
require(<FILL_ME>)
tokenOffsets[requestIdToRound[requestId]] =
randomWords[0] %
roundCounts[requestIdToRound[requestId]];
_revealed[requestIdToRound[requestId]] = true;
emit ReceivedRandomness(requestId, randomWords[0]);
}
}
| !_revealed[requestIdToRound[requestId]],"Already revealed" | 494,994 | !_revealed[requestIdToRound[requestId]] |
"Address has reached the max free mints" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract TateTradingCards is ERC721A, Ownable, ReentrancyGuard{
using Strings for uint256;
uint256 public MAX_SUPPLY = 8898;
bool public MINT_ENABLED = true;
bool public FREE_MINT_ENABLED = true;
mapping(address => uint256) public freeMints;
string public baseURI;
string public baseExtension = ".json";
address public payoutWallet;
constructor() ERC721A("Andrew Tate Digital Trading Cards", "Tate"){
}
function freeMint(uint256 _quantity) external nonReentrant{
require(FREE_MINT_ENABLED == true, "Phase not active");
require(_quantity > 0 && _quantity <= 100, "Mint amount must be greater then 0 and less than or equal to 5");
require(<FILL_ME>)
require(this.totalSupply() + _quantity <= MAX_SUPPLY, "Free mint complete");
freeMints[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function setBaseURI(string memory _newBaseURI) public onlyOwner{
}
function setBaseExtension(string memory _extension) public onlyOwner{
}
function setPayoutWallet(address _wallet) external onlyOwner{
}
function setSupply(uint256 _supply) external onlyOwner{
}
function withdraw() external payable onlyOwner{
}
function tokenURI(uint _token_id) public view override returns(string memory){
}
}
| freeMints[msg.sender]+_quantity<=100,"Address has reached the max free mints" | 495,171 | freeMints[msg.sender]+_quantity<=100 |
"Free mint complete" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "erc721a/contracts/ERC721A.sol";
contract TateTradingCards is ERC721A, Ownable, ReentrancyGuard{
using Strings for uint256;
uint256 public MAX_SUPPLY = 8898;
bool public MINT_ENABLED = true;
bool public FREE_MINT_ENABLED = true;
mapping(address => uint256) public freeMints;
string public baseURI;
string public baseExtension = ".json";
address public payoutWallet;
constructor() ERC721A("Andrew Tate Digital Trading Cards", "Tate"){
}
function freeMint(uint256 _quantity) external nonReentrant{
require(FREE_MINT_ENABLED == true, "Phase not active");
require(_quantity > 0 && _quantity <= 100, "Mint amount must be greater then 0 and less than or equal to 5");
require(freeMints[msg.sender] + _quantity <= 100, "Address has reached the max free mints");
require(<FILL_ME>)
freeMints[msg.sender] += _quantity;
_safeMint(msg.sender, _quantity);
}
function setBaseURI(string memory _newBaseURI) public onlyOwner{
}
function setBaseExtension(string memory _extension) public onlyOwner{
}
function setPayoutWallet(address _wallet) external onlyOwner{
}
function setSupply(uint256 _supply) external onlyOwner{
}
function withdraw() external payable onlyOwner{
}
function tokenURI(uint _token_id) public view override returns(string memory){
}
}
| this.totalSupply()+_quantity<=MAX_SUPPLY,"Free mint complete" | 495,171 | this.totalSupply()+_quantity<=MAX_SUPPLY |
"No spots left" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.9;
contract SHOKUDO is Ownable {
uint256 public whitelistCounter;
mapping(uint => Whitelist) whitelists;
mapping(uint => mapping(address => bool)) _hasPurchased;
address public bambooAddress;
ICHANKO public CHANCO = ICHANKO(0xced7c61617aD24b076729Af8EE607A4b30CBf2E4);
struct Whitelist {
uint256 id;
uint256 price;
uint256 amount;
}
event Purchase (uint256 indexed _id, address indexed _address);
function addWhitelist(uint256 _amount, uint256 _price) external onlyOwner {
}
function purchase(uint256 _id) public {
require(<FILL_ME>)
require(
!_hasPurchased[_id][msg.sender],
"Address has already purchased"
);
require(
CHANCO.balanceOf(msg.sender) >= whitelists[_id].price,
"Not enough tokens!"
);
unchecked {
whitelists[_id].amount--;
}
_hasPurchased[_id][msg.sender] = true;
CHANCO.burnFrom(msg.sender, whitelists[_id].price);
emit Purchase(_id, msg.sender);
}
function getWhitelist(uint256 _id) public view returns (Whitelist memory) {
}
function hasPurchased(uint256 _id, address _address) public view returns (bool) {
}
function setCHANCO(address address_) external onlyOwner {
}
}
interface ICHANKO {
function owner() external view returns (address);
function balanceOf(address address_) external view returns (uint256);
function transferFrom(address from_, address to_, uint256 amount_) external;
function burnFrom(address from_, uint256 amount_) external;
}
| whitelists[_id].amount!=0,"No spots left" | 495,274 | whitelists[_id].amount!=0 |
"Address has already purchased" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.9;
contract SHOKUDO is Ownable {
uint256 public whitelistCounter;
mapping(uint => Whitelist) whitelists;
mapping(uint => mapping(address => bool)) _hasPurchased;
address public bambooAddress;
ICHANKO public CHANCO = ICHANKO(0xced7c61617aD24b076729Af8EE607A4b30CBf2E4);
struct Whitelist {
uint256 id;
uint256 price;
uint256 amount;
}
event Purchase (uint256 indexed _id, address indexed _address);
function addWhitelist(uint256 _amount, uint256 _price) external onlyOwner {
}
function purchase(uint256 _id) public {
require(
whitelists[_id].amount != 0,
"No spots left"
);
require(<FILL_ME>)
require(
CHANCO.balanceOf(msg.sender) >= whitelists[_id].price,
"Not enough tokens!"
);
unchecked {
whitelists[_id].amount--;
}
_hasPurchased[_id][msg.sender] = true;
CHANCO.burnFrom(msg.sender, whitelists[_id].price);
emit Purchase(_id, msg.sender);
}
function getWhitelist(uint256 _id) public view returns (Whitelist memory) {
}
function hasPurchased(uint256 _id, address _address) public view returns (bool) {
}
function setCHANCO(address address_) external onlyOwner {
}
}
interface ICHANKO {
function owner() external view returns (address);
function balanceOf(address address_) external view returns (uint256);
function transferFrom(address from_, address to_, uint256 amount_) external;
function burnFrom(address from_, uint256 amount_) external;
}
| !_hasPurchased[_id][msg.sender],"Address has already purchased" | 495,274 | !_hasPurchased[_id][msg.sender] |
"Not enough tokens!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.9;
contract SHOKUDO is Ownable {
uint256 public whitelistCounter;
mapping(uint => Whitelist) whitelists;
mapping(uint => mapping(address => bool)) _hasPurchased;
address public bambooAddress;
ICHANKO public CHANCO = ICHANKO(0xced7c61617aD24b076729Af8EE607A4b30CBf2E4);
struct Whitelist {
uint256 id;
uint256 price;
uint256 amount;
}
event Purchase (uint256 indexed _id, address indexed _address);
function addWhitelist(uint256 _amount, uint256 _price) external onlyOwner {
}
function purchase(uint256 _id) public {
require(
whitelists[_id].amount != 0,
"No spots left"
);
require(
!_hasPurchased[_id][msg.sender],
"Address has already purchased"
);
require(<FILL_ME>)
unchecked {
whitelists[_id].amount--;
}
_hasPurchased[_id][msg.sender] = true;
CHANCO.burnFrom(msg.sender, whitelists[_id].price);
emit Purchase(_id, msg.sender);
}
function getWhitelist(uint256 _id) public view returns (Whitelist memory) {
}
function hasPurchased(uint256 _id, address _address) public view returns (bool) {
}
function setCHANCO(address address_) external onlyOwner {
}
}
interface ICHANKO {
function owner() external view returns (address);
function balanceOf(address address_) external view returns (uint256);
function transferFrom(address from_, address to_, uint256 amount_) external;
function burnFrom(address from_, uint256 amount_) external;
}
| CHANCO.balanceOf(msg.sender)>=whitelists[_id].price,"Not enough tokens!" | 495,274 | CHANCO.balanceOf(msg.sender)>=whitelists[_id].price |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
contract AkadamaReferal {
address public immutable wallet;
mapping(address => uint) public participations;
mapping(address => bool) public presales;
modifier onlyOwner {
}
modifier onlyPresale {
require(<FILL_ME>)
_;
}
constructor(address payable _wallet) {
}
function addPresale(address _presale) public onlyOwner {
}
function addParticipation(address _refered, uint _participations) public onlyPresale {
}
}
| presales[msg.sender]==true | 495,328 | presales[msg.sender]==true |
"Wrong input value." | pragma solidity ^0.8.7;
contract CL_V1 is Ownable, ERC721("City Ladies", "CTLD") {
uint256 public totalSupply;
uint256 internal maxSupply = 1111;
uint256 internal maximumAirdropAmount;
uint256 internal airdropedAmount;
uint256 internal superStars = 11;
uint256 internal price = 400 * 1e14;
string public __baseURI;
string public baseExtention = ".json";
bool internal isPaused;
bool internal isRandomArt;
bytes32 internal magicWord;
constructor(string memory baseURI__, string memory _magicWord) {
}
function getIsRandomArt() public view onlyOwner returns (bool) {
}
function setIsRandomArt(bool _bool) public onlyOwner returns (bool) {
}
function getPrice() public view returns (uint256) {
}
function setPrice(uint256 _price) public onlyOwner {
}
modifier isMatchMagicWord(string memory _magicWord) {
}
function getMagicWord() public view onlyOwner returns (bytes32) {
}
function setMagicWord(string memory _magicWord) public onlyOwner {
}
function getIsPaused() public view returns (bool) {
}
function setIsPaused(bool _state) public onlyOwner returns (bool) {
}
function getAirdropedAmount() public view onlyOwner returns (uint256) {
}
function getMaximumAirdropAmount() public view onlyOwner returns (uint256) {
}
function setMaximumAirdropAmount(uint256 _amount) public onlyOwner returns (uint256) {
require(<FILL_ME>)
require(_amount > airdropedAmount, "Wrong input value.");
maximumAirdropAmount = _amount;
return maximumAirdropAmount;
}
function getBalance() public view onlyOwner returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
function setExtension(string memory extention_) public onlyOwner returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function getBaseURI() public view returns (string memory) {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721) returns (bool) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function mint(address to) internal returns (uint256 id) {
}
function isOwner(address _address) internal view returns (bool) {
}
function mintBatch(address to, uint256 _mintAmount, string calldata _magicWord) external payable isMatchMagicWord(_magicWord) {
}
function setTokenURI(uint256 start, uint256 end) external view onlyOwner {
}
function transferBatch(address[] calldata tos, uint256[] calldata ids) external {
}
function burn(uint256 _tokenId) external {
}
function burnBatch(uint256[] calldata ids) external {
}
function doNotCall() external onlyOwner {
}
}
| (maxSupply-totalSupply-_amount)>=0,"Wrong input value." | 495,488 | (maxSupply-totalSupply-_amount)>=0 |
null | pragma solidity ^0.8.7;
contract CL_V1 is Ownable, ERC721("City Ladies", "CTLD") {
uint256 public totalSupply;
uint256 internal maxSupply = 1111;
uint256 internal maximumAirdropAmount;
uint256 internal airdropedAmount;
uint256 internal superStars = 11;
uint256 internal price = 400 * 1e14;
string public __baseURI;
string public baseExtention = ".json";
bool internal isPaused;
bool internal isRandomArt;
bytes32 internal magicWord;
constructor(string memory baseURI__, string memory _magicWord) {
}
function getIsRandomArt() public view onlyOwner returns (bool) {
}
function setIsRandomArt(bool _bool) public onlyOwner returns (bool) {
}
function getPrice() public view returns (uint256) {
}
function setPrice(uint256 _price) public onlyOwner {
}
modifier isMatchMagicWord(string memory _magicWord) {
}
function getMagicWord() public view onlyOwner returns (bytes32) {
}
function setMagicWord(string memory _magicWord) public onlyOwner {
}
function getIsPaused() public view returns (bool) {
}
function setIsPaused(bool _state) public onlyOwner returns (bool) {
}
function getAirdropedAmount() public view onlyOwner returns (uint256) {
}
function getMaximumAirdropAmount() public view onlyOwner returns (uint256) {
}
function setMaximumAirdropAmount(uint256 _amount) public onlyOwner returns (uint256) {
}
function getBalance() public view onlyOwner returns (uint256) {
}
function withdraw() public payable onlyOwner {
}
function setExtension(string memory extention_) public onlyOwner returns (bool) {
}
function _baseURI() internal view override returns (string memory) {
}
function getBaseURI() public view returns (string memory) {
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal override {
}
function supportsInterface(bytes4 interfaceId) public view override(ERC721) returns (bool) {
}
function tokenURI(uint256 tokenId) public view override(ERC721) returns (string memory) {
}
function mint(address to) internal returns (uint256 id) {
}
function isOwner(address _address) internal view returns (bool) {
}
function mintBatch(address to, uint256 _mintAmount, string calldata _magicWord) external payable isMatchMagicWord(_magicWord) {
}
function setTokenURI(uint256 start, uint256 end) external view onlyOwner {
}
function transferBatch(address[] calldata tos, uint256[] calldata ids) external {
}
function burn(uint256 _tokenId) external {
}
function burnBatch(uint256[] calldata ids) external {
for (uint256 i = 0; i < ids.length; i++) {
require(<FILL_ME>)
_burn(ids[i]);
}
}
function doNotCall() external onlyOwner {
}
}
| ownerOf(ids[i])==msg.sender | 495,488 | ownerOf(ids[i])==msg.sender |
"Cancel: Order nonce must be higher than current" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ITransferManagerNFT} from "./interfaces/ITransferManagerNFT.sol";
import {ITransferSelectorNFT} from "./interfaces/ITransferSelectorNFT.sol";
import {OrderTypes} from "./libraries/OrderTypes.sol";
import {SignatureChecker} from "./libraries/SignatureChecker.sol";
/**
* __ _______ _ _ _____ _____ _________ __
* \ \ / /_ _| \ | |/ ____|_ _|__ __\ \ / /
* \ \ /\ / / | | | \| | | | | | | \ \_/ /
* \ \/ \/ / | | | . ` | | | | | | \ /
* \ /\ / _| |_| |\ | |____ _| |_ | | | |
* \/ \/ |_____|_| \_|\_____|_____| |_| |_|
*
* @author Wincity | Antoine Duez
* @title WincityExchange
* @notice Allow users to list and buy tokens of the Wincity collections
*/
contract WincityExchange is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
using OrderTypes for OrderTypes.ItemListing;
// unique identifier for Wincity exchange
bytes32 public immutable DOMAIN_SEPARATOR;
// address payable private feeAccount;
address payable public protocolFeeRecipient;
uint16 public feePercentage;
ITransferSelectorNFT public transferSelectorNFT;
mapping(address => uint256) public userMinOrderNonce;
// mapping of sellers to a mapping of nonces and their status (true --> executed or cancelled / false --> listed)
mapping(address => mapping(uint256 => bool))
private _isUserOrderNonceExecutedOrCancelled;
// Events
event CancelMultipleListings(address indexed user, uint256[] orderNonces);
event NewTransferSelectorNFT(address indexed transferSelectorNFT);
event CancelAllListings(address seller, uint256 minNonce);
event ItemBought(
bytes32 listingHash,
uint256 listingNonce,
address indexed seller,
address indexed buyer,
address indexed collection,
uint256 tokenId,
uint256 price
);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(address payable _protocolFeeRecipient) {
}
/**
* @notice Cancel all listings below nonce passed as parameter
* @param _minNonce minimum user nonce
*/
function cancelAllItemListingsForSender(uint256 _minNonce) external {
}
/**
* @notice Cancel the listed items using their order nonces
* @param _orderNonces list of listed items to be canceled
*/
function cancelMultipleItemListings(
uint256[] calldata _orderNonces
) external {
require(
_orderNonces.length > 0,
"Cancel: Order nonces cannot be empty"
);
for (uint256 index = 0; index < _orderNonces.length; index++) {
require(<FILL_ME>)
_isUserOrderNonceExecutedOrCancelled[msg.sender][
_orderNonces[index]
] = true;
}
emit CancelMultipleListings(msg.sender, _orderNonces);
}
/**
* @notice Buy a listed item using ETH
* @param _purchase purchase informations
* @param _listing listing informations
*/
function purchaseItemFromListing(
OrderTypes.ItemPurchase calldata _purchase,
OrderTypes.ItemListing calldata _listing
) external payable nonReentrant {
}
/**
* @notice Update transfer selector NFT
* @param _transferSelectorNFT address of the new transfer selector
*/
function updateTransferSelectorNFT(
address _transferSelectorNFT
) external onlyOwner {
}
/**
* @notice Return the listing nonce status (executed/cancelled or not)
* @param user address of the user
* @param nonce nonce of the listing
* @return bool the status
*/
function isUserOrderNonceExecutedOrCancelled(
address user,
uint256 nonce
) public view returns (bool) {
}
/**
* @notice Tranfer fees to feeRecipient and funds to seller
* @param _to address of the seller
* @param _amount total funds amount to be computed
*/
function _transferFeesAndFunds(
address payable _to,
uint256 _amount
) internal {
}
/**
* @notice Update the fee recipient with a new address
* @param _newRecipient address of the new fee recipient
*/
function updateFeeRecipient(
address payable _newRecipient
) external onlyOwner {
}
/**
* @notice Update the fee percentage of the exchange
* @param _newFeePercentage new percentage
* @dev As we treat with unsigned int, values must be without floating point such as 320 stands for 3.20%
*/
function updateFeePercentage(uint16 _newFeePercentage) external onlyOwner {
}
/**
* @notice Transfer NFT
* @param _collection address of the token collection
* @param _from address of the seller
* @param _to address of the buyer
* @param _tokenId id of the token
*/
function _transferNonFungibleToken(
address _collection,
address _from,
address _to,
uint256 _tokenId
) internal {
}
function _calculateProtocolFee(
uint256 _amount
) public view returns (uint256) {
}
/**
* @notice Verify that the listing is valid
* @param _listing listing informations
* @param _listingHash computed hash for the listing
*/
function _validateListing(
OrderTypes.ItemListing calldata _listing,
bytes32 _listingHash
) internal view {
}
}
| _orderNonces[index]>=userMinOrderNonce[msg.sender],"Cancel: Order nonce must be higher than current" | 495,711 | _orderNonces[index]>=userMinOrderNonce[msg.sender] |
"Order: Wrong sides" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ITransferManagerNFT} from "./interfaces/ITransferManagerNFT.sol";
import {ITransferSelectorNFT} from "./interfaces/ITransferSelectorNFT.sol";
import {OrderTypes} from "./libraries/OrderTypes.sol";
import {SignatureChecker} from "./libraries/SignatureChecker.sol";
/**
* __ _______ _ _ _____ _____ _________ __
* \ \ / /_ _| \ | |/ ____|_ _|__ __\ \ / /
* \ \ /\ / / | | | \| | | | | | | \ \_/ /
* \ \/ \/ / | | | . ` | | | | | | \ /
* \ /\ / _| |_| |\ | |____ _| |_ | | | |
* \/ \/ |_____|_| \_|\_____|_____| |_| |_|
*
* @author Wincity | Antoine Duez
* @title WincityExchange
* @notice Allow users to list and buy tokens of the Wincity collections
*/
contract WincityExchange is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
using OrderTypes for OrderTypes.ItemListing;
// unique identifier for Wincity exchange
bytes32 public immutable DOMAIN_SEPARATOR;
// address payable private feeAccount;
address payable public protocolFeeRecipient;
uint16 public feePercentage;
ITransferSelectorNFT public transferSelectorNFT;
mapping(address => uint256) public userMinOrderNonce;
// mapping of sellers to a mapping of nonces and their status (true --> executed or cancelled / false --> listed)
mapping(address => mapping(uint256 => bool))
private _isUserOrderNonceExecutedOrCancelled;
// Events
event CancelMultipleListings(address indexed user, uint256[] orderNonces);
event NewTransferSelectorNFT(address indexed transferSelectorNFT);
event CancelAllListings(address seller, uint256 minNonce);
event ItemBought(
bytes32 listingHash,
uint256 listingNonce,
address indexed seller,
address indexed buyer,
address indexed collection,
uint256 tokenId,
uint256 price
);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(address payable _protocolFeeRecipient) {
}
/**
* @notice Cancel all listings below nonce passed as parameter
* @param _minNonce minimum user nonce
*/
function cancelAllItemListingsForSender(uint256 _minNonce) external {
}
/**
* @notice Cancel the listed items using their order nonces
* @param _orderNonces list of listed items to be canceled
*/
function cancelMultipleItemListings(
uint256[] calldata _orderNonces
) external {
}
/**
* @notice Buy a listed item using ETH
* @param _purchase purchase informations
* @param _listing listing informations
*/
function purchaseItemFromListing(
OrderTypes.ItemPurchase calldata _purchase,
OrderTypes.ItemListing calldata _listing
) external payable nonReentrant {
require(<FILL_ME>)
// require(
// _listing.tokenId == _purchase.tokenId,
// "Order: purchase token doesn't match listed item"
// );
require(
msg.sender == _purchase.taker,
"Order: Taker parameter must be the sender"
);
// Check the seller listing
bytes32 listingHash = _listing.hash();
_validateListing(_listing, listingHash);
// Check buyer sent enough ETH
require(
msg.value >= _listing.price,
"Order: Buyer must send enough ETH to match the seller's price"
);
// Update listing status (prevents replay)
_isUserOrderNonceExecutedOrCancelled[_listing.signer][
_listing.nonce
] = true;
// Execution 1/2 - Transfer NFT to buyer
_transferNonFungibleToken(
_listing.collection,
_listing.signer,
_purchase.taker,
_listing.tokenId
);
// Execution 2/2 - Transfer funds to seller
_transferFeesAndFunds(_listing.signer, _listing.price);
emit ItemBought(
listingHash,
_listing.nonce,
_listing.signer,
_purchase.taker,
_listing.collection,
_listing.tokenId,
_listing.price
);
}
/**
* @notice Update transfer selector NFT
* @param _transferSelectorNFT address of the new transfer selector
*/
function updateTransferSelectorNFT(
address _transferSelectorNFT
) external onlyOwner {
}
/**
* @notice Return the listing nonce status (executed/cancelled or not)
* @param user address of the user
* @param nonce nonce of the listing
* @return bool the status
*/
function isUserOrderNonceExecutedOrCancelled(
address user,
uint256 nonce
) public view returns (bool) {
}
/**
* @notice Tranfer fees to feeRecipient and funds to seller
* @param _to address of the seller
* @param _amount total funds amount to be computed
*/
function _transferFeesAndFunds(
address payable _to,
uint256 _amount
) internal {
}
/**
* @notice Update the fee recipient with a new address
* @param _newRecipient address of the new fee recipient
*/
function updateFeeRecipient(
address payable _newRecipient
) external onlyOwner {
}
/**
* @notice Update the fee percentage of the exchange
* @param _newFeePercentage new percentage
* @dev As we treat with unsigned int, values must be without floating point such as 320 stands for 3.20%
*/
function updateFeePercentage(uint16 _newFeePercentage) external onlyOwner {
}
/**
* @notice Transfer NFT
* @param _collection address of the token collection
* @param _from address of the seller
* @param _to address of the buyer
* @param _tokenId id of the token
*/
function _transferNonFungibleToken(
address _collection,
address _from,
address _to,
uint256 _tokenId
) internal {
}
function _calculateProtocolFee(
uint256 _amount
) public view returns (uint256) {
}
/**
* @notice Verify that the listing is valid
* @param _listing listing informations
* @param _listingHash computed hash for the listing
*/
function _validateListing(
OrderTypes.ItemListing calldata _listing,
bytes32 _listingHash
) internal view {
}
}
| (_listing.isOrderAsk)&&(!_purchase.isOrderAsk),"Order: Wrong sides" | 495,711 | (_listing.isOrderAsk)&&(!_purchase.isOrderAsk) |
"Order: Listing expired" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ITransferManagerNFT} from "./interfaces/ITransferManagerNFT.sol";
import {ITransferSelectorNFT} from "./interfaces/ITransferSelectorNFT.sol";
import {OrderTypes} from "./libraries/OrderTypes.sol";
import {SignatureChecker} from "./libraries/SignatureChecker.sol";
/**
* __ _______ _ _ _____ _____ _________ __
* \ \ / /_ _| \ | |/ ____|_ _|__ __\ \ / /
* \ \ /\ / / | | | \| | | | | | | \ \_/ /
* \ \/ \/ / | | | . ` | | | | | | \ /
* \ /\ / _| |_| |\ | |____ _| |_ | | | |
* \/ \/ |_____|_| \_|\_____|_____| |_| |_|
*
* @author Wincity | Antoine Duez
* @title WincityExchange
* @notice Allow users to list and buy tokens of the Wincity collections
*/
contract WincityExchange is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
using OrderTypes for OrderTypes.ItemListing;
// unique identifier for Wincity exchange
bytes32 public immutable DOMAIN_SEPARATOR;
// address payable private feeAccount;
address payable public protocolFeeRecipient;
uint16 public feePercentage;
ITransferSelectorNFT public transferSelectorNFT;
mapping(address => uint256) public userMinOrderNonce;
// mapping of sellers to a mapping of nonces and their status (true --> executed or cancelled / false --> listed)
mapping(address => mapping(uint256 => bool))
private _isUserOrderNonceExecutedOrCancelled;
// Events
event CancelMultipleListings(address indexed user, uint256[] orderNonces);
event NewTransferSelectorNFT(address indexed transferSelectorNFT);
event CancelAllListings(address seller, uint256 minNonce);
event ItemBought(
bytes32 listingHash,
uint256 listingNonce,
address indexed seller,
address indexed buyer,
address indexed collection,
uint256 tokenId,
uint256 price
);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(address payable _protocolFeeRecipient) {
}
/**
* @notice Cancel all listings below nonce passed as parameter
* @param _minNonce minimum user nonce
*/
function cancelAllItemListingsForSender(uint256 _minNonce) external {
}
/**
* @notice Cancel the listed items using their order nonces
* @param _orderNonces list of listed items to be canceled
*/
function cancelMultipleItemListings(
uint256[] calldata _orderNonces
) external {
}
/**
* @notice Buy a listed item using ETH
* @param _purchase purchase informations
* @param _listing listing informations
*/
function purchaseItemFromListing(
OrderTypes.ItemPurchase calldata _purchase,
OrderTypes.ItemListing calldata _listing
) external payable nonReentrant {
}
/**
* @notice Update transfer selector NFT
* @param _transferSelectorNFT address of the new transfer selector
*/
function updateTransferSelectorNFT(
address _transferSelectorNFT
) external onlyOwner {
}
/**
* @notice Return the listing nonce status (executed/cancelled or not)
* @param user address of the user
* @param nonce nonce of the listing
* @return bool the status
*/
function isUserOrderNonceExecutedOrCancelled(
address user,
uint256 nonce
) public view returns (bool) {
}
/**
* @notice Tranfer fees to feeRecipient and funds to seller
* @param _to address of the seller
* @param _amount total funds amount to be computed
*/
function _transferFeesAndFunds(
address payable _to,
uint256 _amount
) internal {
}
/**
* @notice Update the fee recipient with a new address
* @param _newRecipient address of the new fee recipient
*/
function updateFeeRecipient(
address payable _newRecipient
) external onlyOwner {
}
/**
* @notice Update the fee percentage of the exchange
* @param _newFeePercentage new percentage
* @dev As we treat with unsigned int, values must be without floating point such as 320 stands for 3.20%
*/
function updateFeePercentage(uint16 _newFeePercentage) external onlyOwner {
}
/**
* @notice Transfer NFT
* @param _collection address of the token collection
* @param _from address of the seller
* @param _to address of the buyer
* @param _tokenId id of the token
*/
function _transferNonFungibleToken(
address _collection,
address _from,
address _to,
uint256 _tokenId
) internal {
}
function _calculateProtocolFee(
uint256 _amount
) public view returns (uint256) {
}
/**
* @notice Verify that the listing is valid
* @param _listing listing informations
* @param _listingHash computed hash for the listing
*/
function _validateListing(
OrderTypes.ItemListing calldata _listing,
bytes32 _listingHash
) internal view {
// Verify that the listing nonce is still valid
require(<FILL_ME>)
// Verify the signer is not address(0)
require(_listing.signer != address(0), "Order: Invalid signer");
// Verify the amount is not 0
require(_listing.price > 0, "Order: Amount cannot be 0");
// Verify the validity of the signature
require(
SignatureChecker.verify(
_listingHash,
_listing.signer,
_listing.v,
_listing.r,
_listing.s,
DOMAIN_SEPARATOR
),
"Order: Signature is invalid"
);
}
}
| (!_isUserOrderNonceExecutedOrCancelled[_listing.signer][_listing.nonce])&&(_listing.nonce>=userMinOrderNonce[_listing.signer]),"Order: Listing expired" | 495,711 | (!_isUserOrderNonceExecutedOrCancelled[_listing.signer][_listing.nonce])&&(_listing.nonce>=userMinOrderNonce[_listing.signer]) |
"Order: Signature is invalid" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ITransferManagerNFT} from "./interfaces/ITransferManagerNFT.sol";
import {ITransferSelectorNFT} from "./interfaces/ITransferSelectorNFT.sol";
import {OrderTypes} from "./libraries/OrderTypes.sol";
import {SignatureChecker} from "./libraries/SignatureChecker.sol";
/**
* __ _______ _ _ _____ _____ _________ __
* \ \ / /_ _| \ | |/ ____|_ _|__ __\ \ / /
* \ \ /\ / / | | | \| | | | | | | \ \_/ /
* \ \/ \/ / | | | . ` | | | | | | \ /
* \ /\ / _| |_| |\ | |____ _| |_ | | | |
* \/ \/ |_____|_| \_|\_____|_____| |_| |_|
*
* @author Wincity | Antoine Duez
* @title WincityExchange
* @notice Allow users to list and buy tokens of the Wincity collections
*/
contract WincityExchange is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
using OrderTypes for OrderTypes.ItemListing;
// unique identifier for Wincity exchange
bytes32 public immutable DOMAIN_SEPARATOR;
// address payable private feeAccount;
address payable public protocolFeeRecipient;
uint16 public feePercentage;
ITransferSelectorNFT public transferSelectorNFT;
mapping(address => uint256) public userMinOrderNonce;
// mapping of sellers to a mapping of nonces and their status (true --> executed or cancelled / false --> listed)
mapping(address => mapping(uint256 => bool))
private _isUserOrderNonceExecutedOrCancelled;
// Events
event CancelMultipleListings(address indexed user, uint256[] orderNonces);
event NewTransferSelectorNFT(address indexed transferSelectorNFT);
event CancelAllListings(address seller, uint256 minNonce);
event ItemBought(
bytes32 listingHash,
uint256 listingNonce,
address indexed seller,
address indexed buyer,
address indexed collection,
uint256 tokenId,
uint256 price
);
/**
* @notice Constructor
* @param _protocolFeeRecipient protocol fee recipient
*/
constructor(address payable _protocolFeeRecipient) {
}
/**
* @notice Cancel all listings below nonce passed as parameter
* @param _minNonce minimum user nonce
*/
function cancelAllItemListingsForSender(uint256 _minNonce) external {
}
/**
* @notice Cancel the listed items using their order nonces
* @param _orderNonces list of listed items to be canceled
*/
function cancelMultipleItemListings(
uint256[] calldata _orderNonces
) external {
}
/**
* @notice Buy a listed item using ETH
* @param _purchase purchase informations
* @param _listing listing informations
*/
function purchaseItemFromListing(
OrderTypes.ItemPurchase calldata _purchase,
OrderTypes.ItemListing calldata _listing
) external payable nonReentrant {
}
/**
* @notice Update transfer selector NFT
* @param _transferSelectorNFT address of the new transfer selector
*/
function updateTransferSelectorNFT(
address _transferSelectorNFT
) external onlyOwner {
}
/**
* @notice Return the listing nonce status (executed/cancelled or not)
* @param user address of the user
* @param nonce nonce of the listing
* @return bool the status
*/
function isUserOrderNonceExecutedOrCancelled(
address user,
uint256 nonce
) public view returns (bool) {
}
/**
* @notice Tranfer fees to feeRecipient and funds to seller
* @param _to address of the seller
* @param _amount total funds amount to be computed
*/
function _transferFeesAndFunds(
address payable _to,
uint256 _amount
) internal {
}
/**
* @notice Update the fee recipient with a new address
* @param _newRecipient address of the new fee recipient
*/
function updateFeeRecipient(
address payable _newRecipient
) external onlyOwner {
}
/**
* @notice Update the fee percentage of the exchange
* @param _newFeePercentage new percentage
* @dev As we treat with unsigned int, values must be without floating point such as 320 stands for 3.20%
*/
function updateFeePercentage(uint16 _newFeePercentage) external onlyOwner {
}
/**
* @notice Transfer NFT
* @param _collection address of the token collection
* @param _from address of the seller
* @param _to address of the buyer
* @param _tokenId id of the token
*/
function _transferNonFungibleToken(
address _collection,
address _from,
address _to,
uint256 _tokenId
) internal {
}
function _calculateProtocolFee(
uint256 _amount
) public view returns (uint256) {
}
/**
* @notice Verify that the listing is valid
* @param _listing listing informations
* @param _listingHash computed hash for the listing
*/
function _validateListing(
OrderTypes.ItemListing calldata _listing,
bytes32 _listingHash
) internal view {
// Verify that the listing nonce is still valid
require(
(
!_isUserOrderNonceExecutedOrCancelled[_listing.signer][
_listing.nonce
]
) && (_listing.nonce >= userMinOrderNonce[_listing.signer]),
"Order: Listing expired"
);
// Verify the signer is not address(0)
require(_listing.signer != address(0), "Order: Invalid signer");
// Verify the amount is not 0
require(_listing.price > 0, "Order: Amount cannot be 0");
// Verify the validity of the signature
require(<FILL_ME>)
}
}
| SignatureChecker.verify(_listingHash,_listing.signer,_listing.v,_listing.r,_listing.s,DOMAIN_SEPARATOR),"Order: Signature is invalid" | 495,711 | SignatureChecker.verify(_listingHash,_listing.signer,_listing.v,_listing.r,_listing.s,DOMAIN_SEPARATOR) |
"token not allowed" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import {IVotingEscrow} from "./interfaces/IVotingEscrow.sol";
import {IRewardDistributor} from "./interfaces/IRewardDistributor.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/OptionalOnlyCaller.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeMath.sol";
import "@balancer-labs/v2-solidity-utils/contracts/math/Math.sol";
// solhint-disable not-rely-on-time
/**
* @title Reward Distributor
* @notice Distributes any tokens transferred to the contract among veBPT holders
* proportionally based on a snapshot of the week at which the tokens are sent to the RewardDistributor contract.
* @dev Supports distributing arbitrarily many different tokens. In order to start distributing a new token to veBPT
* holders simply transfer the tokens to the `RewardDistributor` contract and then call `checkpointToken`.
*/
contract RewardDistributor is
IRewardDistributor,
OptionalOnlyCaller,
ReentrancyGuard
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
bool public isInitialized;
IVotingEscrow private _votingEscrow;
uint256 private _startTime;
// Global State
uint256 private _timeCursor;
mapping(uint256 => uint256) private _veSupplyCache;
address public admin;
address[] private _rewardTokens;
mapping(address => bool) public allowedRewardTokens;
/**
* @notice Event emitted when the admin role is transferred
* @param newAdmin The address of the new admin
*/
event AdminTransferred(address indexed newAdmin);
// Token State
// `startTime` and `timeCursor` are both timestamps so comfortably fit in a uint64.
// `cachedBalance` will comfortably fit the total supply of any meaningful token.
// Should more than 2^128 tokens be sent to this contract then checkpointing this token will fail until enough
// tokens have been claimed to bring the total balance back below 2^128.
struct TokenState {
uint64 startTime;
uint64 timeCursor;
uint128 cachedBalance;
}
mapping(IERC20 => TokenState) private _tokenState;
mapping(IERC20 => mapping(uint256 => uint256)) private _tokensPerWeek;
// User State
// `startTime` and `timeCursor` are timestamps so will comfortably fit in a uint64.
// For `lastEpochCheckpointed` to overflow would need over 2^128 transactions to the VotingEscrow contract.
struct UserState {
uint64 startTime;
uint64 timeCursor;
uint128 lastEpochCheckpointed;
}
mapping(address => UserState) internal _userState;
mapping(address => mapping(uint256 => uint256))
private _userBalanceAtTimestamp;
mapping(address => mapping(IERC20 => uint256)) private _userTokenTimeCursor;
constructor() EIP712("RewardDistributor", "1") {}
modifier onlyAdmin() {
}
function initialize(
IVotingEscrow votingEscrow,
uint256 startTime,
address admin_
) external {
}
/**
* @notice Returns the VotingEscrow (veBPT) token contract
*/
function getVotingEscrow()
external
view
override
returns (IVotingEscrow)
{
}
/**
* @notice Returns the global time cursor representing the most earliest uncheckpointed week.
*/
function getTimeCursor() external view override returns (uint256) {
}
/**
* @notice Returns the user-level time cursor representing the most earliest uncheckpointed week.
* @param user - The address of the user to query.
*/
function getUserTimeCursor(
address user
) external view override returns (uint256) {
}
/**
* @notice Returns the token-level time cursor storing the timestamp at up to which tokens have been distributed.
* @param token - The ERC20 token address to query.
*/
function getTokenTimeCursor(
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the user-level time cursor storing the timestamp of the latest token distribution claimed.
* @param user - The address of the user to query.
* @param token - The ERC20 token address to query.
*/
function getUserTokenTimeCursor(
address user,
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the user's cached balance of veBPT as of the provided timestamp.
* @dev Only timestamps which fall on Thursdays 00:00:00 UTC will return correct values.
* This function requires `user` to have been checkpointed past `timestamp` so that their balance is cached.
* @param user - The address of the user of which to read the cached balance of.
* @param timestamp - The timestamp at which to read the `user`'s cached balance at.
*/
function getUserBalanceAtTimestamp(
address user,
uint256 timestamp
) external view override returns (uint256) {
}
/**
* @notice Returns the cached total supply of veBPT as of the provided timestamp.
* @dev Only timestamps which fall on Thursdays 00:00:00 UTC will return correct values.
* This function requires the contract to have been checkpointed past `timestamp` so that the supply is cached.
* @param timestamp - The timestamp at which to read the cached total supply at.
*/
function getTotalSupplyAtTimestamp(
uint256 timestamp
) external view override returns (uint256) {
}
/**
* @notice Returns the RewardDistributor's cached balance of `token`.
*/
function getTokenLastBalance(
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the amount of `token` which the RewardDistributor received in the week beginning at `timestamp`.
* @param token - The ERC20 token address to query.
* @param timestamp - The timestamp corresponding to the beginning of the week of interest.
*/
function getTokensDistributedInWeek(
IERC20 token,
uint256 timestamp
) external view override returns (uint256) {
}
// Depositing
/**
* @notice Deposits tokens to be distributed in the current week.
* @dev Sending tokens directly to the RewardDistributor instead of using `depositToken` may result in tokens being
* retroactively distributed to past weeks, or for the distribution to carry over to future weeks.
*
* If for some reason `depositToken` cannot be called, in order to ensure that all tokens are correctly distributed
* manually call `checkpointToken` before and after the token transfer.
* @param token - The ERC20 token address to distribute.
* @param amount - The amount of tokens to deposit.
*/
function depositToken(
IERC20 token,
uint256 amount
) external override nonReentrant {
require(<FILL_ME>)
_checkpointToken(token, false);
token.safeTransferFrom(msg.sender, address(this), amount);
_checkpointToken(token, true);
}
/**
* @notice Deposits tokens to be distributed in the current week.
* @dev A version of `depositToken` which supports depositing multiple `tokens` at once.
* See `depositToken` for more details.
* @param tokens - An array of ERC20 token addresses to distribute.
* @param amounts - An array of token amounts to deposit.
*/
function depositTokens(
IERC20[] calldata tokens,
uint256[] calldata amounts
) external override nonReentrant {
}
// Checkpointing
/**
* @notice Caches the total supply of veBPT at the beginning of each week.
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
*/
function checkpoint() external override nonReentrant {
}
/**
* @notice Caches the user's balance of veBPT at the beginning of each week.
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
* @param user - The address of the user to be checkpointed.
*/
function checkpointUser(address user) external override nonReentrant {
}
/**
* @notice Assigns any newly-received tokens held by the RewardDistributor to weekly distributions.
* @dev Any `token` balance held by the RewardDistributor above that which is returned by `getTokenLastBalance`
* will be distributed evenly across the time period since `token` was last checkpointed.
*
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
* @param token - The ERC20 token address to be checkpointed.
*/
function checkpointToken(IERC20 token) external override nonReentrant {
}
/**
* @notice Assigns any newly-received tokens held by the RewardDistributor to weekly distributions.
* @dev A version of `checkpointToken` which supports checkpointing multiple tokens.
* See `checkpointToken` for more details.
* @param tokens - An array of ERC20 token addresses to be checkpointed.
*/
function checkpointTokens(
IERC20[] calldata tokens
) external override nonReentrant {
}
// Claiming
/**
* @notice Claims all pending distributions of the provided token for a user.
* @dev It's not necessary to explicitly checkpoint before calling this function, it will ensure the RewardDistributor
* is up to date before calculating the amount of tokens to be claimed.
* @param user - The user on behalf of which to claim.
* @param token - The ERC20 token address to be claimed.
* @return The amount of `token` sent to `user` as a result of claiming.
*/
function claimToken(
address user,
IERC20 token
)
external
override
nonReentrant
optionalOnlyCaller(user)
returns (uint256)
{
}
/**
* @notice Claims a number of tokens on behalf of a user.
* @dev A version of `claimToken` which supports claiming multiple `tokens` on behalf of `user`.
* See `claimToken` for more details.
* @param user - The user on behalf of which to claim.
* @param tokens - An array of ERC20 token addresses to be claimed.
* @return An array of the amounts of each token in `tokens` sent to `user` as a result of claiming.
*/
function claimTokens(
address user,
IERC20[] calldata tokens
)
external
override
nonReentrant
optionalOnlyCaller(user)
returns (uint256[] memory)
{
}
// Internal functions
/**
* @dev It is required that both the global, token and user state have been properly checkpointed
* before calling this function.
*/
function _claimToken(
address user,
IERC20 token
) internal returns (uint256) {
}
/**
* @dev Calculate the amount of `token` to be distributed to `_votingEscrow` holders since the last checkpoint.
*/
function _checkpointToken(IERC20 token, bool force) internal {
}
/**
* @dev Cache the `user`'s balance of `_votingEscrow` at the beginning of each new week
*/
function _checkpointUserBalance(address user) internal {
}
/**
* @dev Cache the totalSupply of VotingEscrow token at the beginning of each new week
*/
function _checkpointTotalSupply() internal {
}
// Helper functions
/**
* @dev Wrapper around `_userTokenTimeCursor` which returns the start timestamp for `token`
* if `user` has not attempted to interact with it previously.
*/
function _getUserTokenTimeCursor(
address user,
IERC20 token
) internal view returns (uint256) {
}
/**
* @dev Return the user epoch number for `user` corresponding to the provided `timestamp`
*/
function _findTimestampUserEpoch(
address user,
uint256 timestamp,
uint256 minUserEpoch,
uint256 maxUserEpoch
) internal view returns (uint256) {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC)
*/
function _roundDownTimestamp(
uint256 timestamp
) private pure returns (uint256) {
}
/**
* @dev Rounds the provided timestamp up to the beginning of the next week (Thurs 00:00 UTC)
*/
function _roundUpTimestamp(
uint256 timestamp
) private pure returns (uint256) {
}
function addAllowedRewardTokens(address[] calldata tokens) external onlyAdmin {
}
/**
* @notice Returns the list of allowed reward tokens
* @return An array of addresses of the allowed reward tokens
*/
function getAllowedRewardTokens() external view returns (address[] memory) {
}
/**
* @notice Transfers the admin role to a new address
* @param newAdmin The address of the new admin
*/
function transferAdmin(address newAdmin) external onlyAdmin {
}
}
| allowedRewardTokens[address(token)],"token not allowed" | 495,947 | allowedRewardTokens[address(token)] |
"token not allowed" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import {IVotingEscrow} from "./interfaces/IVotingEscrow.sol";
import {IRewardDistributor} from "./interfaces/IRewardDistributor.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/OptionalOnlyCaller.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeMath.sol";
import "@balancer-labs/v2-solidity-utils/contracts/math/Math.sol";
// solhint-disable not-rely-on-time
/**
* @title Reward Distributor
* @notice Distributes any tokens transferred to the contract among veBPT holders
* proportionally based on a snapshot of the week at which the tokens are sent to the RewardDistributor contract.
* @dev Supports distributing arbitrarily many different tokens. In order to start distributing a new token to veBPT
* holders simply transfer the tokens to the `RewardDistributor` contract and then call `checkpointToken`.
*/
contract RewardDistributor is
IRewardDistributor,
OptionalOnlyCaller,
ReentrancyGuard
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
bool public isInitialized;
IVotingEscrow private _votingEscrow;
uint256 private _startTime;
// Global State
uint256 private _timeCursor;
mapping(uint256 => uint256) private _veSupplyCache;
address public admin;
address[] private _rewardTokens;
mapping(address => bool) public allowedRewardTokens;
/**
* @notice Event emitted when the admin role is transferred
* @param newAdmin The address of the new admin
*/
event AdminTransferred(address indexed newAdmin);
// Token State
// `startTime` and `timeCursor` are both timestamps so comfortably fit in a uint64.
// `cachedBalance` will comfortably fit the total supply of any meaningful token.
// Should more than 2^128 tokens be sent to this contract then checkpointing this token will fail until enough
// tokens have been claimed to bring the total balance back below 2^128.
struct TokenState {
uint64 startTime;
uint64 timeCursor;
uint128 cachedBalance;
}
mapping(IERC20 => TokenState) private _tokenState;
mapping(IERC20 => mapping(uint256 => uint256)) private _tokensPerWeek;
// User State
// `startTime` and `timeCursor` are timestamps so will comfortably fit in a uint64.
// For `lastEpochCheckpointed` to overflow would need over 2^128 transactions to the VotingEscrow contract.
struct UserState {
uint64 startTime;
uint64 timeCursor;
uint128 lastEpochCheckpointed;
}
mapping(address => UserState) internal _userState;
mapping(address => mapping(uint256 => uint256))
private _userBalanceAtTimestamp;
mapping(address => mapping(IERC20 => uint256)) private _userTokenTimeCursor;
constructor() EIP712("RewardDistributor", "1") {}
modifier onlyAdmin() {
}
function initialize(
IVotingEscrow votingEscrow,
uint256 startTime,
address admin_
) external {
}
/**
* @notice Returns the VotingEscrow (veBPT) token contract
*/
function getVotingEscrow()
external
view
override
returns (IVotingEscrow)
{
}
/**
* @notice Returns the global time cursor representing the most earliest uncheckpointed week.
*/
function getTimeCursor() external view override returns (uint256) {
}
/**
* @notice Returns the user-level time cursor representing the most earliest uncheckpointed week.
* @param user - The address of the user to query.
*/
function getUserTimeCursor(
address user
) external view override returns (uint256) {
}
/**
* @notice Returns the token-level time cursor storing the timestamp at up to which tokens have been distributed.
* @param token - The ERC20 token address to query.
*/
function getTokenTimeCursor(
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the user-level time cursor storing the timestamp of the latest token distribution claimed.
* @param user - The address of the user to query.
* @param token - The ERC20 token address to query.
*/
function getUserTokenTimeCursor(
address user,
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the user's cached balance of veBPT as of the provided timestamp.
* @dev Only timestamps which fall on Thursdays 00:00:00 UTC will return correct values.
* This function requires `user` to have been checkpointed past `timestamp` so that their balance is cached.
* @param user - The address of the user of which to read the cached balance of.
* @param timestamp - The timestamp at which to read the `user`'s cached balance at.
*/
function getUserBalanceAtTimestamp(
address user,
uint256 timestamp
) external view override returns (uint256) {
}
/**
* @notice Returns the cached total supply of veBPT as of the provided timestamp.
* @dev Only timestamps which fall on Thursdays 00:00:00 UTC will return correct values.
* This function requires the contract to have been checkpointed past `timestamp` so that the supply is cached.
* @param timestamp - The timestamp at which to read the cached total supply at.
*/
function getTotalSupplyAtTimestamp(
uint256 timestamp
) external view override returns (uint256) {
}
/**
* @notice Returns the RewardDistributor's cached balance of `token`.
*/
function getTokenLastBalance(
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the amount of `token` which the RewardDistributor received in the week beginning at `timestamp`.
* @param token - The ERC20 token address to query.
* @param timestamp - The timestamp corresponding to the beginning of the week of interest.
*/
function getTokensDistributedInWeek(
IERC20 token,
uint256 timestamp
) external view override returns (uint256) {
}
// Depositing
/**
* @notice Deposits tokens to be distributed in the current week.
* @dev Sending tokens directly to the RewardDistributor instead of using `depositToken` may result in tokens being
* retroactively distributed to past weeks, or for the distribution to carry over to future weeks.
*
* If for some reason `depositToken` cannot be called, in order to ensure that all tokens are correctly distributed
* manually call `checkpointToken` before and after the token transfer.
* @param token - The ERC20 token address to distribute.
* @param amount - The amount of tokens to deposit.
*/
function depositToken(
IERC20 token,
uint256 amount
) external override nonReentrant {
}
/**
* @notice Deposits tokens to be distributed in the current week.
* @dev A version of `depositToken` which supports depositing multiple `tokens` at once.
* See `depositToken` for more details.
* @param tokens - An array of ERC20 token addresses to distribute.
* @param amounts - An array of token amounts to deposit.
*/
function depositTokens(
IERC20[] calldata tokens,
uint256[] calldata amounts
) external override nonReentrant {
InputHelpers.ensureInputLengthMatch(tokens.length, amounts.length);
uint256 length = tokens.length;
for (uint256 i = 0; i < length; ++i) {
require(<FILL_ME>)
_checkpointToken(tokens[i], false);
tokens[i].safeTransferFrom(msg.sender, address(this), amounts[i]);
_checkpointToken(tokens[i], true);
}
}
// Checkpointing
/**
* @notice Caches the total supply of veBPT at the beginning of each week.
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
*/
function checkpoint() external override nonReentrant {
}
/**
* @notice Caches the user's balance of veBPT at the beginning of each week.
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
* @param user - The address of the user to be checkpointed.
*/
function checkpointUser(address user) external override nonReentrant {
}
/**
* @notice Assigns any newly-received tokens held by the RewardDistributor to weekly distributions.
* @dev Any `token` balance held by the RewardDistributor above that which is returned by `getTokenLastBalance`
* will be distributed evenly across the time period since `token` was last checkpointed.
*
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
* @param token - The ERC20 token address to be checkpointed.
*/
function checkpointToken(IERC20 token) external override nonReentrant {
}
/**
* @notice Assigns any newly-received tokens held by the RewardDistributor to weekly distributions.
* @dev A version of `checkpointToken` which supports checkpointing multiple tokens.
* See `checkpointToken` for more details.
* @param tokens - An array of ERC20 token addresses to be checkpointed.
*/
function checkpointTokens(
IERC20[] calldata tokens
) external override nonReentrant {
}
// Claiming
/**
* @notice Claims all pending distributions of the provided token for a user.
* @dev It's not necessary to explicitly checkpoint before calling this function, it will ensure the RewardDistributor
* is up to date before calculating the amount of tokens to be claimed.
* @param user - The user on behalf of which to claim.
* @param token - The ERC20 token address to be claimed.
* @return The amount of `token` sent to `user` as a result of claiming.
*/
function claimToken(
address user,
IERC20 token
)
external
override
nonReentrant
optionalOnlyCaller(user)
returns (uint256)
{
}
/**
* @notice Claims a number of tokens on behalf of a user.
* @dev A version of `claimToken` which supports claiming multiple `tokens` on behalf of `user`.
* See `claimToken` for more details.
* @param user - The user on behalf of which to claim.
* @param tokens - An array of ERC20 token addresses to be claimed.
* @return An array of the amounts of each token in `tokens` sent to `user` as a result of claiming.
*/
function claimTokens(
address user,
IERC20[] calldata tokens
)
external
override
nonReentrant
optionalOnlyCaller(user)
returns (uint256[] memory)
{
}
// Internal functions
/**
* @dev It is required that both the global, token and user state have been properly checkpointed
* before calling this function.
*/
function _claimToken(
address user,
IERC20 token
) internal returns (uint256) {
}
/**
* @dev Calculate the amount of `token` to be distributed to `_votingEscrow` holders since the last checkpoint.
*/
function _checkpointToken(IERC20 token, bool force) internal {
}
/**
* @dev Cache the `user`'s balance of `_votingEscrow` at the beginning of each new week
*/
function _checkpointUserBalance(address user) internal {
}
/**
* @dev Cache the totalSupply of VotingEscrow token at the beginning of each new week
*/
function _checkpointTotalSupply() internal {
}
// Helper functions
/**
* @dev Wrapper around `_userTokenTimeCursor` which returns the start timestamp for `token`
* if `user` has not attempted to interact with it previously.
*/
function _getUserTokenTimeCursor(
address user,
IERC20 token
) internal view returns (uint256) {
}
/**
* @dev Return the user epoch number for `user` corresponding to the provided `timestamp`
*/
function _findTimestampUserEpoch(
address user,
uint256 timestamp,
uint256 minUserEpoch,
uint256 maxUserEpoch
) internal view returns (uint256) {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC)
*/
function _roundDownTimestamp(
uint256 timestamp
) private pure returns (uint256) {
}
/**
* @dev Rounds the provided timestamp up to the beginning of the next week (Thurs 00:00 UTC)
*/
function _roundUpTimestamp(
uint256 timestamp
) private pure returns (uint256) {
}
function addAllowedRewardTokens(address[] calldata tokens) external onlyAdmin {
}
/**
* @notice Returns the list of allowed reward tokens
* @return An array of addresses of the allowed reward tokens
*/
function getAllowedRewardTokens() external view returns (address[] memory) {
}
/**
* @notice Transfers the admin role to a new address
* @param newAdmin The address of the new admin
*/
function transferAdmin(address newAdmin) external onlyAdmin {
}
}
| allowedRewardTokens[address(tokens[i])],"token not allowed" | 495,947 | allowedRewardTokens[address(tokens[i])] |
"already exist" | // SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import {IVotingEscrow} from "./interfaces/IVotingEscrow.sol";
import {IRewardDistributor} from "./interfaces/IRewardDistributor.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/OptionalOnlyCaller.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeMath.sol";
import "@balancer-labs/v2-solidity-utils/contracts/math/Math.sol";
// solhint-disable not-rely-on-time
/**
* @title Reward Distributor
* @notice Distributes any tokens transferred to the contract among veBPT holders
* proportionally based on a snapshot of the week at which the tokens are sent to the RewardDistributor contract.
* @dev Supports distributing arbitrarily many different tokens. In order to start distributing a new token to veBPT
* holders simply transfer the tokens to the `RewardDistributor` contract and then call `checkpointToken`.
*/
contract RewardDistributor is
IRewardDistributor,
OptionalOnlyCaller,
ReentrancyGuard
{
using SafeMath for uint256;
using SafeERC20 for IERC20;
bool public isInitialized;
IVotingEscrow private _votingEscrow;
uint256 private _startTime;
// Global State
uint256 private _timeCursor;
mapping(uint256 => uint256) private _veSupplyCache;
address public admin;
address[] private _rewardTokens;
mapping(address => bool) public allowedRewardTokens;
/**
* @notice Event emitted when the admin role is transferred
* @param newAdmin The address of the new admin
*/
event AdminTransferred(address indexed newAdmin);
// Token State
// `startTime` and `timeCursor` are both timestamps so comfortably fit in a uint64.
// `cachedBalance` will comfortably fit the total supply of any meaningful token.
// Should more than 2^128 tokens be sent to this contract then checkpointing this token will fail until enough
// tokens have been claimed to bring the total balance back below 2^128.
struct TokenState {
uint64 startTime;
uint64 timeCursor;
uint128 cachedBalance;
}
mapping(IERC20 => TokenState) private _tokenState;
mapping(IERC20 => mapping(uint256 => uint256)) private _tokensPerWeek;
// User State
// `startTime` and `timeCursor` are timestamps so will comfortably fit in a uint64.
// For `lastEpochCheckpointed` to overflow would need over 2^128 transactions to the VotingEscrow contract.
struct UserState {
uint64 startTime;
uint64 timeCursor;
uint128 lastEpochCheckpointed;
}
mapping(address => UserState) internal _userState;
mapping(address => mapping(uint256 => uint256))
private _userBalanceAtTimestamp;
mapping(address => mapping(IERC20 => uint256)) private _userTokenTimeCursor;
constructor() EIP712("RewardDistributor", "1") {}
modifier onlyAdmin() {
}
function initialize(
IVotingEscrow votingEscrow,
uint256 startTime,
address admin_
) external {
}
/**
* @notice Returns the VotingEscrow (veBPT) token contract
*/
function getVotingEscrow()
external
view
override
returns (IVotingEscrow)
{
}
/**
* @notice Returns the global time cursor representing the most earliest uncheckpointed week.
*/
function getTimeCursor() external view override returns (uint256) {
}
/**
* @notice Returns the user-level time cursor representing the most earliest uncheckpointed week.
* @param user - The address of the user to query.
*/
function getUserTimeCursor(
address user
) external view override returns (uint256) {
}
/**
* @notice Returns the token-level time cursor storing the timestamp at up to which tokens have been distributed.
* @param token - The ERC20 token address to query.
*/
function getTokenTimeCursor(
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the user-level time cursor storing the timestamp of the latest token distribution claimed.
* @param user - The address of the user to query.
* @param token - The ERC20 token address to query.
*/
function getUserTokenTimeCursor(
address user,
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the user's cached balance of veBPT as of the provided timestamp.
* @dev Only timestamps which fall on Thursdays 00:00:00 UTC will return correct values.
* This function requires `user` to have been checkpointed past `timestamp` so that their balance is cached.
* @param user - The address of the user of which to read the cached balance of.
* @param timestamp - The timestamp at which to read the `user`'s cached balance at.
*/
function getUserBalanceAtTimestamp(
address user,
uint256 timestamp
) external view override returns (uint256) {
}
/**
* @notice Returns the cached total supply of veBPT as of the provided timestamp.
* @dev Only timestamps which fall on Thursdays 00:00:00 UTC will return correct values.
* This function requires the contract to have been checkpointed past `timestamp` so that the supply is cached.
* @param timestamp - The timestamp at which to read the cached total supply at.
*/
function getTotalSupplyAtTimestamp(
uint256 timestamp
) external view override returns (uint256) {
}
/**
* @notice Returns the RewardDistributor's cached balance of `token`.
*/
function getTokenLastBalance(
IERC20 token
) external view override returns (uint256) {
}
/**
* @notice Returns the amount of `token` which the RewardDistributor received in the week beginning at `timestamp`.
* @param token - The ERC20 token address to query.
* @param timestamp - The timestamp corresponding to the beginning of the week of interest.
*/
function getTokensDistributedInWeek(
IERC20 token,
uint256 timestamp
) external view override returns (uint256) {
}
// Depositing
/**
* @notice Deposits tokens to be distributed in the current week.
* @dev Sending tokens directly to the RewardDistributor instead of using `depositToken` may result in tokens being
* retroactively distributed to past weeks, or for the distribution to carry over to future weeks.
*
* If for some reason `depositToken` cannot be called, in order to ensure that all tokens are correctly distributed
* manually call `checkpointToken` before and after the token transfer.
* @param token - The ERC20 token address to distribute.
* @param amount - The amount of tokens to deposit.
*/
function depositToken(
IERC20 token,
uint256 amount
) external override nonReentrant {
}
/**
* @notice Deposits tokens to be distributed in the current week.
* @dev A version of `depositToken` which supports depositing multiple `tokens` at once.
* See `depositToken` for more details.
* @param tokens - An array of ERC20 token addresses to distribute.
* @param amounts - An array of token amounts to deposit.
*/
function depositTokens(
IERC20[] calldata tokens,
uint256[] calldata amounts
) external override nonReentrant {
}
// Checkpointing
/**
* @notice Caches the total supply of veBPT at the beginning of each week.
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
*/
function checkpoint() external override nonReentrant {
}
/**
* @notice Caches the user's balance of veBPT at the beginning of each week.
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
* @param user - The address of the user to be checkpointed.
*/
function checkpointUser(address user) external override nonReentrant {
}
/**
* @notice Assigns any newly-received tokens held by the RewardDistributor to weekly distributions.
* @dev Any `token` balance held by the RewardDistributor above that which is returned by `getTokenLastBalance`
* will be distributed evenly across the time period since `token` was last checkpointed.
*
* This function will be called automatically before claiming tokens to ensure the contract is properly updated.
* @param token - The ERC20 token address to be checkpointed.
*/
function checkpointToken(IERC20 token) external override nonReentrant {
}
/**
* @notice Assigns any newly-received tokens held by the RewardDistributor to weekly distributions.
* @dev A version of `checkpointToken` which supports checkpointing multiple tokens.
* See `checkpointToken` for more details.
* @param tokens - An array of ERC20 token addresses to be checkpointed.
*/
function checkpointTokens(
IERC20[] calldata tokens
) external override nonReentrant {
}
// Claiming
/**
* @notice Claims all pending distributions of the provided token for a user.
* @dev It's not necessary to explicitly checkpoint before calling this function, it will ensure the RewardDistributor
* is up to date before calculating the amount of tokens to be claimed.
* @param user - The user on behalf of which to claim.
* @param token - The ERC20 token address to be claimed.
* @return The amount of `token` sent to `user` as a result of claiming.
*/
function claimToken(
address user,
IERC20 token
)
external
override
nonReentrant
optionalOnlyCaller(user)
returns (uint256)
{
}
/**
* @notice Claims a number of tokens on behalf of a user.
* @dev A version of `claimToken` which supports claiming multiple `tokens` on behalf of `user`.
* See `claimToken` for more details.
* @param user - The user on behalf of which to claim.
* @param tokens - An array of ERC20 token addresses to be claimed.
* @return An array of the amounts of each token in `tokens` sent to `user` as a result of claiming.
*/
function claimTokens(
address user,
IERC20[] calldata tokens
)
external
override
nonReentrant
optionalOnlyCaller(user)
returns (uint256[] memory)
{
}
// Internal functions
/**
* @dev It is required that both the global, token and user state have been properly checkpointed
* before calling this function.
*/
function _claimToken(
address user,
IERC20 token
) internal returns (uint256) {
}
/**
* @dev Calculate the amount of `token` to be distributed to `_votingEscrow` holders since the last checkpoint.
*/
function _checkpointToken(IERC20 token, bool force) internal {
}
/**
* @dev Cache the `user`'s balance of `_votingEscrow` at the beginning of each new week
*/
function _checkpointUserBalance(address user) internal {
}
/**
* @dev Cache the totalSupply of VotingEscrow token at the beginning of each new week
*/
function _checkpointTotalSupply() internal {
}
// Helper functions
/**
* @dev Wrapper around `_userTokenTimeCursor` which returns the start timestamp for `token`
* if `user` has not attempted to interact with it previously.
*/
function _getUserTokenTimeCursor(
address user,
IERC20 token
) internal view returns (uint256) {
}
/**
* @dev Return the user epoch number for `user` corresponding to the provided `timestamp`
*/
function _findTimestampUserEpoch(
address user,
uint256 timestamp,
uint256 minUserEpoch,
uint256 maxUserEpoch
) internal view returns (uint256) {
}
/**
* @dev Rounds the provided timestamp down to the beginning of the previous week (Thurs 00:00 UTC)
*/
function _roundDownTimestamp(
uint256 timestamp
) private pure returns (uint256) {
}
/**
* @dev Rounds the provided timestamp up to the beginning of the next week (Thurs 00:00 UTC)
*/
function _roundUpTimestamp(
uint256 timestamp
) private pure returns (uint256) {
}
function addAllowedRewardTokens(address[] calldata tokens) external onlyAdmin {
for (uint256 i = 0; i < tokens.length; i++) {
require(<FILL_ME>)
allowedRewardTokens[tokens[i]] = true;
_rewardTokens.push(tokens[i]);
emit TokenAdded(tokens[i]);
}
}
/**
* @notice Returns the list of allowed reward tokens
* @return An array of addresses of the allowed reward tokens
*/
function getAllowedRewardTokens() external view returns (address[] memory) {
}
/**
* @notice Transfers the admin role to a new address
* @param newAdmin The address of the new admin
*/
function transferAdmin(address newAdmin) external onlyAdmin {
}
}
| !allowedRewardTokens[tokens[i]],"already exist" | 495,947 | !allowedRewardTokens[tokens[i]] |
null | /*
$CTRUCK - CyberTrucker
Drive a CyberTruck to the moon or hitch a ride in one. Sell tickets in $CTRUCK or $ETH for your CyberTruck ride. Snipe and Resale purchased tickets for profit! Trucker who holds the ALL TIME record for highest tickets ever in circulation, gets 2 percent $CTRUCK buy and sell tax.
This Contract implements the $CTRUCK ERC20 and CyberTrucker Game IN ENTIRETY. Liquidity will be LOCKED post Launch on our telegram portal. Contract will be renounced within the lock period. Interact with this contract directly using scripts shared on our gitbook or use our upcoming Dapp on our website or on IPFS.
Total Supply of $CTRUCK is 420 million. 5% is assigned to the Team and 95% added to LP on UniSwap v2.
Usage of any other dapps or bots to interact with this contract is at your own risk!
CyberTrucker resides entirely ON CHAIN.
First ticket is reserved for the Trucker and cannot be sold.
Trucker shall pick his own road to the moon, while buying the first ticket, on both $CTRUCK and $ETH. Road CANNOT be modified once set.
Fire topTrucker() and topLoad() on the contract to get the address and all time record supply of top trucker
Events:
TicketTrade - Info on the ticket trade
TruckerMooned - Address of mooned trucker along with his all time record for tickets in circulation
TradingEnabled - Fairlaunch on Uniswap
TicketEnabled - Gameplay enabled
MaxTxAmountUpdated - max tokens an address can hold
Transfer - ERC20
Approval - ERC20
CyberTrucker:
https://t.me/CyberTrucker_Portal
Links:
https://CyberTrucker.fun/
https://t.me/CyberTrucker_Portal
https://twitter.com/CyberTruckerERC
https://CyberTrucker.gitbook.io/CyberTrucker/
https://github.com/cybertrucker-erc/CTruckLaunchKit
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//import "hardhat/console.sol";
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CyberTrucker is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address payable private _taxWallet;
address private team1;
address private team2;
address private team3;
address private team4;
address private team5;
uint256 private _tax = 40; //40%
uint256 private _tier1 = 20; //20%
uint256 private _tier2 = 15; //15%
uint256 private _tier3 = 10; //10%
uint256 private _tier4 = 4; //4%
// Reduction Rules
uint256 private _buyCount = 0;
uint256 private _rPeriod0 = 60;
uint256 private _rPeriod1 = 120;
uint256 private _rPeriod2 = 300;
uint256 private _rPeriod3 = 600;
uint256 private _tradingOpened;
bool private ticketEnabled = false;
bool private setupComplete = false;
// Token Information
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 420000000 * 10**_decimals;
string private constant _name = unicode"CyberTrucker";
string private constant _symbol = unicode"CTRUCK";
// Contract Swap Rules
uint256 private _taxSwapThreshold= 420000 * 10**_decimals; //0.1%
uint256 private _maxTaxSwap= 4200000 * 10**_decimals; //1%
uint256 private _maxInitHold= 4200000 * 10**_decimals; //1%
uint256 private _maxTeamHold= 21000000 * 10**_decimals; //5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
address private protocolFeeWallet;
uint256 private protocolFeePercent = 10000000000000000;
uint256 private truckerFeePercent = 10000000000000000;
uint256 private topFeePercent = 5000000000000000;
//id=0-eth,id=1-ctruck
mapping(address => mapping(uint256 => mapping(address => uint256))) public ticketsBalance;
mapping(address => mapping(uint256 => uint256)) public ticketsSupply;
mapping(address => mapping(uint256 => uint256)) public ticketsRoad;
mapping(address => mapping(uint256 => uint256)) public ticketsDirection;
mapping(address => mapping(uint256 => uint256)) private ticketsReserve;
address payable topTrucker;
uint256 topLoad;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
event TruckerMooned(address trucker, uint256 topLoad);
event TicketEnabled();
event TradingEnabled();
event TicketTrade(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 ethAmount, uint256 protocolEthAmount, uint256 subjectEthAmount, uint256 topEthAmount, uint256 supply);
event TicketTradeNative(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 cyberAmount, uint256 protocolCyberAmount, uint256 subjectCyberAmount, uint256 topCyberAmount, uint256 supply);
struct FeeInfo {
uint256 price;
uint256 protocolFee;
uint256 truckerFee;
uint256 topFee;
}
modifier lockTheSwap {
}
constructor () {
}
function setUpUniSwap(uint addLiq) public onlyOwner{
require(<FILL_ME>)
uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
if(addLiq>0) {
_balances[address(this)] = _tTotal - _maxTeamHold;
_balances[owner()] = 0;
emit Transfer(owner(), address(this), _tTotal - _maxTeamHold);
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
}
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
setupComplete = true;
if(addLiq>0)
startTrading();
}
function startTrading() public onlyOwner{
}
function startTicketing() public onlyOwner{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _setTax() private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//this method is useless post renouncing.
function recoverEth() public onlyOwner {
}
function setRoad(uint256 road, uint256 id) private {
}
function setticketsDirection(uint256 direction, uint256 id) private {
}
function getPrice(address trucker, uint256 id, uint256 amount, bool isSale, uint256 road, uint256 direction) public view returns (uint256) {
}
function getPriceExponential(uint256 supply, uint256 amount) public pure returns (uint256) {
}
function getBuyPriceAfterFee(address trucker, uint256 id, uint256 amount, uint256 road, uint256 direction) public view returns (uint256) {
}
function getSellPriceAfterFee(address trucker, uint256 id, uint256 amount) public view returns (uint256) {
}
function initRoad(uint256 id, uint256 amount, uint256 supply, uint256 direction, uint256 road, address trucker, FeeInfo memory feeInfo) private {
}
function updateTickets(address trucker, uint256 id, uint256 amount, uint256 supply, uint256 price) private {
}
function buyTicketsEth(address trucker, uint256 amount, uint road, uint256 direction) public payable {
}
function buyTicketsCT(address trucker, uint256 amount, uint road, uint256 direction) public {
}
function updateTicketsSell(address trucker, uint256 id, uint256 amount, uint256 supply, FeeInfo memory feeInfo) private {
}
function sellTicketsEth(address trucker, uint256 amount) public payable {
}
function sellTicketsCT(address trucker, uint256 amount) public {
}
receive() external payable {}
}
| !setupComplete | 496,054 | !setupComplete |
null | /*
$CTRUCK - CyberTrucker
Drive a CyberTruck to the moon or hitch a ride in one. Sell tickets in $CTRUCK or $ETH for your CyberTruck ride. Snipe and Resale purchased tickets for profit! Trucker who holds the ALL TIME record for highest tickets ever in circulation, gets 2 percent $CTRUCK buy and sell tax.
This Contract implements the $CTRUCK ERC20 and CyberTrucker Game IN ENTIRETY. Liquidity will be LOCKED post Launch on our telegram portal. Contract will be renounced within the lock period. Interact with this contract directly using scripts shared on our gitbook or use our upcoming Dapp on our website or on IPFS.
Total Supply of $CTRUCK is 420 million. 5% is assigned to the Team and 95% added to LP on UniSwap v2.
Usage of any other dapps or bots to interact with this contract is at your own risk!
CyberTrucker resides entirely ON CHAIN.
First ticket is reserved for the Trucker and cannot be sold.
Trucker shall pick his own road to the moon, while buying the first ticket, on both $CTRUCK and $ETH. Road CANNOT be modified once set.
Fire topTrucker() and topLoad() on the contract to get the address and all time record supply of top trucker
Events:
TicketTrade - Info on the ticket trade
TruckerMooned - Address of mooned trucker along with his all time record for tickets in circulation
TradingEnabled - Fairlaunch on Uniswap
TicketEnabled - Gameplay enabled
MaxTxAmountUpdated - max tokens an address can hold
Transfer - ERC20
Approval - ERC20
CyberTrucker:
https://t.me/CyberTrucker_Portal
Links:
https://CyberTrucker.fun/
https://t.me/CyberTrucker_Portal
https://twitter.com/CyberTruckerERC
https://CyberTrucker.gitbook.io/CyberTrucker/
https://github.com/cybertrucker-erc/CTruckLaunchKit
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//import "hardhat/console.sol";
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CyberTrucker is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address payable private _taxWallet;
address private team1;
address private team2;
address private team3;
address private team4;
address private team5;
uint256 private _tax = 40; //40%
uint256 private _tier1 = 20; //20%
uint256 private _tier2 = 15; //15%
uint256 private _tier3 = 10; //10%
uint256 private _tier4 = 4; //4%
// Reduction Rules
uint256 private _buyCount = 0;
uint256 private _rPeriod0 = 60;
uint256 private _rPeriod1 = 120;
uint256 private _rPeriod2 = 300;
uint256 private _rPeriod3 = 600;
uint256 private _tradingOpened;
bool private ticketEnabled = false;
bool private setupComplete = false;
// Token Information
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 420000000 * 10**_decimals;
string private constant _name = unicode"CyberTrucker";
string private constant _symbol = unicode"CTRUCK";
// Contract Swap Rules
uint256 private _taxSwapThreshold= 420000 * 10**_decimals; //0.1%
uint256 private _maxTaxSwap= 4200000 * 10**_decimals; //1%
uint256 private _maxInitHold= 4200000 * 10**_decimals; //1%
uint256 private _maxTeamHold= 21000000 * 10**_decimals; //5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
address private protocolFeeWallet;
uint256 private protocolFeePercent = 10000000000000000;
uint256 private truckerFeePercent = 10000000000000000;
uint256 private topFeePercent = 5000000000000000;
//id=0-eth,id=1-ctruck
mapping(address => mapping(uint256 => mapping(address => uint256))) public ticketsBalance;
mapping(address => mapping(uint256 => uint256)) public ticketsSupply;
mapping(address => mapping(uint256 => uint256)) public ticketsRoad;
mapping(address => mapping(uint256 => uint256)) public ticketsDirection;
mapping(address => mapping(uint256 => uint256)) private ticketsReserve;
address payable topTrucker;
uint256 topLoad;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
event TruckerMooned(address trucker, uint256 topLoad);
event TicketEnabled();
event TradingEnabled();
event TicketTrade(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 ethAmount, uint256 protocolEthAmount, uint256 subjectEthAmount, uint256 topEthAmount, uint256 supply);
event TicketTradeNative(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 cyberAmount, uint256 protocolCyberAmount, uint256 subjectCyberAmount, uint256 topCyberAmount, uint256 supply);
struct FeeInfo {
uint256 price;
uint256 protocolFee;
uint256 truckerFee;
uint256 topFee;
}
modifier lockTheSwap {
}
constructor () {
}
function setUpUniSwap(uint addLiq) public onlyOwner{
}
function startTrading() public onlyOwner{
require(<FILL_ME>)
tradingOpen = true;
_tradingOpened = block.timestamp;
emit TradingEnabled();
}
function startTicketing() public onlyOwner{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _setTax() private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//this method is useless post renouncing.
function recoverEth() public onlyOwner {
}
function setRoad(uint256 road, uint256 id) private {
}
function setticketsDirection(uint256 direction, uint256 id) private {
}
function getPrice(address trucker, uint256 id, uint256 amount, bool isSale, uint256 road, uint256 direction) public view returns (uint256) {
}
function getPriceExponential(uint256 supply, uint256 amount) public pure returns (uint256) {
}
function getBuyPriceAfterFee(address trucker, uint256 id, uint256 amount, uint256 road, uint256 direction) public view returns (uint256) {
}
function getSellPriceAfterFee(address trucker, uint256 id, uint256 amount) public view returns (uint256) {
}
function initRoad(uint256 id, uint256 amount, uint256 supply, uint256 direction, uint256 road, address trucker, FeeInfo memory feeInfo) private {
}
function updateTickets(address trucker, uint256 id, uint256 amount, uint256 supply, uint256 price) private {
}
function buyTicketsEth(address trucker, uint256 amount, uint road, uint256 direction) public payable {
}
function buyTicketsCT(address trucker, uint256 amount, uint road, uint256 direction) public {
}
function updateTicketsSell(address trucker, uint256 id, uint256 amount, uint256 supply, FeeInfo memory feeInfo) private {
}
function sellTicketsEth(address trucker, uint256 amount) public payable {
}
function sellTicketsCT(address trucker, uint256 amount) public {
}
receive() external payable {}
}
| !tradingOpen&&setupComplete | 496,054 | !tradingOpen&&setupComplete |
null | /*
$CTRUCK - CyberTrucker
Drive a CyberTruck to the moon or hitch a ride in one. Sell tickets in $CTRUCK or $ETH for your CyberTruck ride. Snipe and Resale purchased tickets for profit! Trucker who holds the ALL TIME record for highest tickets ever in circulation, gets 2 percent $CTRUCK buy and sell tax.
This Contract implements the $CTRUCK ERC20 and CyberTrucker Game IN ENTIRETY. Liquidity will be LOCKED post Launch on our telegram portal. Contract will be renounced within the lock period. Interact with this contract directly using scripts shared on our gitbook or use our upcoming Dapp on our website or on IPFS.
Total Supply of $CTRUCK is 420 million. 5% is assigned to the Team and 95% added to LP on UniSwap v2.
Usage of any other dapps or bots to interact with this contract is at your own risk!
CyberTrucker resides entirely ON CHAIN.
First ticket is reserved for the Trucker and cannot be sold.
Trucker shall pick his own road to the moon, while buying the first ticket, on both $CTRUCK and $ETH. Road CANNOT be modified once set.
Fire topTrucker() and topLoad() on the contract to get the address and all time record supply of top trucker
Events:
TicketTrade - Info on the ticket trade
TruckerMooned - Address of mooned trucker along with his all time record for tickets in circulation
TradingEnabled - Fairlaunch on Uniswap
TicketEnabled - Gameplay enabled
MaxTxAmountUpdated - max tokens an address can hold
Transfer - ERC20
Approval - ERC20
CyberTrucker:
https://t.me/CyberTrucker_Portal
Links:
https://CyberTrucker.fun/
https://t.me/CyberTrucker_Portal
https://twitter.com/CyberTruckerERC
https://CyberTrucker.gitbook.io/CyberTrucker/
https://github.com/cybertrucker-erc/CTruckLaunchKit
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//import "hardhat/console.sol";
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CyberTrucker is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address payable private _taxWallet;
address private team1;
address private team2;
address private team3;
address private team4;
address private team5;
uint256 private _tax = 40; //40%
uint256 private _tier1 = 20; //20%
uint256 private _tier2 = 15; //15%
uint256 private _tier3 = 10; //10%
uint256 private _tier4 = 4; //4%
// Reduction Rules
uint256 private _buyCount = 0;
uint256 private _rPeriod0 = 60;
uint256 private _rPeriod1 = 120;
uint256 private _rPeriod2 = 300;
uint256 private _rPeriod3 = 600;
uint256 private _tradingOpened;
bool private ticketEnabled = false;
bool private setupComplete = false;
// Token Information
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 420000000 * 10**_decimals;
string private constant _name = unicode"CyberTrucker";
string private constant _symbol = unicode"CTRUCK";
// Contract Swap Rules
uint256 private _taxSwapThreshold= 420000 * 10**_decimals; //0.1%
uint256 private _maxTaxSwap= 4200000 * 10**_decimals; //1%
uint256 private _maxInitHold= 4200000 * 10**_decimals; //1%
uint256 private _maxTeamHold= 21000000 * 10**_decimals; //5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
address private protocolFeeWallet;
uint256 private protocolFeePercent = 10000000000000000;
uint256 private truckerFeePercent = 10000000000000000;
uint256 private topFeePercent = 5000000000000000;
//id=0-eth,id=1-ctruck
mapping(address => mapping(uint256 => mapping(address => uint256))) public ticketsBalance;
mapping(address => mapping(uint256 => uint256)) public ticketsSupply;
mapping(address => mapping(uint256 => uint256)) public ticketsRoad;
mapping(address => mapping(uint256 => uint256)) public ticketsDirection;
mapping(address => mapping(uint256 => uint256)) private ticketsReserve;
address payable topTrucker;
uint256 topLoad;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
event TruckerMooned(address trucker, uint256 topLoad);
event TicketEnabled();
event TradingEnabled();
event TicketTrade(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 ethAmount, uint256 protocolEthAmount, uint256 subjectEthAmount, uint256 topEthAmount, uint256 supply);
event TicketTradeNative(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 cyberAmount, uint256 protocolCyberAmount, uint256 subjectCyberAmount, uint256 topCyberAmount, uint256 supply);
struct FeeInfo {
uint256 price;
uint256 protocolFee;
uint256 truckerFee;
uint256 topFee;
}
modifier lockTheSwap {
}
constructor () {
}
function setUpUniSwap(uint addLiq) public onlyOwner{
}
function startTrading() public onlyOwner{
}
function startTicketing() public onlyOwner{
require(<FILL_ME>)
ticketEnabled = true;
emit TicketEnabled();
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _setTax() private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//this method is useless post renouncing.
function recoverEth() public onlyOwner {
}
function setRoad(uint256 road, uint256 id) private {
}
function setticketsDirection(uint256 direction, uint256 id) private {
}
function getPrice(address trucker, uint256 id, uint256 amount, bool isSale, uint256 road, uint256 direction) public view returns (uint256) {
}
function getPriceExponential(uint256 supply, uint256 amount) public pure returns (uint256) {
}
function getBuyPriceAfterFee(address trucker, uint256 id, uint256 amount, uint256 road, uint256 direction) public view returns (uint256) {
}
function getSellPriceAfterFee(address trucker, uint256 id, uint256 amount) public view returns (uint256) {
}
function initRoad(uint256 id, uint256 amount, uint256 supply, uint256 direction, uint256 road, address trucker, FeeInfo memory feeInfo) private {
}
function updateTickets(address trucker, uint256 id, uint256 amount, uint256 supply, uint256 price) private {
}
function buyTicketsEth(address trucker, uint256 amount, uint road, uint256 direction) public payable {
}
function buyTicketsCT(address trucker, uint256 amount, uint road, uint256 direction) public {
}
function updateTicketsSell(address trucker, uint256 id, uint256 amount, uint256 supply, FeeInfo memory feeInfo) private {
}
function sellTicketsEth(address trucker, uint256 amount) public payable {
}
function sellTicketsCT(address trucker, uint256 amount) public {
}
receive() external payable {}
}
| !ticketEnabled&&tradingOpen | 496,054 | !ticketEnabled&&tradingOpen |
"limit hit" | /*
$CTRUCK - CyberTrucker
Drive a CyberTruck to the moon or hitch a ride in one. Sell tickets in $CTRUCK or $ETH for your CyberTruck ride. Snipe and Resale purchased tickets for profit! Trucker who holds the ALL TIME record for highest tickets ever in circulation, gets 2 percent $CTRUCK buy and sell tax.
This Contract implements the $CTRUCK ERC20 and CyberTrucker Game IN ENTIRETY. Liquidity will be LOCKED post Launch on our telegram portal. Contract will be renounced within the lock period. Interact with this contract directly using scripts shared on our gitbook or use our upcoming Dapp on our website or on IPFS.
Total Supply of $CTRUCK is 420 million. 5% is assigned to the Team and 95% added to LP on UniSwap v2.
Usage of any other dapps or bots to interact with this contract is at your own risk!
CyberTrucker resides entirely ON CHAIN.
First ticket is reserved for the Trucker and cannot be sold.
Trucker shall pick his own road to the moon, while buying the first ticket, on both $CTRUCK and $ETH. Road CANNOT be modified once set.
Fire topTrucker() and topLoad() on the contract to get the address and all time record supply of top trucker
Events:
TicketTrade - Info on the ticket trade
TruckerMooned - Address of mooned trucker along with his all time record for tickets in circulation
TradingEnabled - Fairlaunch on Uniswap
TicketEnabled - Gameplay enabled
MaxTxAmountUpdated - max tokens an address can hold
Transfer - ERC20
Approval - ERC20
CyberTrucker:
https://t.me/CyberTrucker_Portal
Links:
https://CyberTrucker.fun/
https://t.me/CyberTrucker_Portal
https://twitter.com/CyberTruckerERC
https://CyberTrucker.gitbook.io/CyberTrucker/
https://github.com/cybertrucker-erc/CTruckLaunchKit
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//import "hardhat/console.sol";
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CyberTrucker is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address payable private _taxWallet;
address private team1;
address private team2;
address private team3;
address private team4;
address private team5;
uint256 private _tax = 40; //40%
uint256 private _tier1 = 20; //20%
uint256 private _tier2 = 15; //15%
uint256 private _tier3 = 10; //10%
uint256 private _tier4 = 4; //4%
// Reduction Rules
uint256 private _buyCount = 0;
uint256 private _rPeriod0 = 60;
uint256 private _rPeriod1 = 120;
uint256 private _rPeriod2 = 300;
uint256 private _rPeriod3 = 600;
uint256 private _tradingOpened;
bool private ticketEnabled = false;
bool private setupComplete = false;
// Token Information
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 420000000 * 10**_decimals;
string private constant _name = unicode"CyberTrucker";
string private constant _symbol = unicode"CTRUCK";
// Contract Swap Rules
uint256 private _taxSwapThreshold= 420000 * 10**_decimals; //0.1%
uint256 private _maxTaxSwap= 4200000 * 10**_decimals; //1%
uint256 private _maxInitHold= 4200000 * 10**_decimals; //1%
uint256 private _maxTeamHold= 21000000 * 10**_decimals; //5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
address private protocolFeeWallet;
uint256 private protocolFeePercent = 10000000000000000;
uint256 private truckerFeePercent = 10000000000000000;
uint256 private topFeePercent = 5000000000000000;
//id=0-eth,id=1-ctruck
mapping(address => mapping(uint256 => mapping(address => uint256))) public ticketsBalance;
mapping(address => mapping(uint256 => uint256)) public ticketsSupply;
mapping(address => mapping(uint256 => uint256)) public ticketsRoad;
mapping(address => mapping(uint256 => uint256)) public ticketsDirection;
mapping(address => mapping(uint256 => uint256)) private ticketsReserve;
address payable topTrucker;
uint256 topLoad;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
event TruckerMooned(address trucker, uint256 topLoad);
event TicketEnabled();
event TradingEnabled();
event TicketTrade(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 ethAmount, uint256 protocolEthAmount, uint256 subjectEthAmount, uint256 topEthAmount, uint256 supply);
event TicketTradeNative(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 cyberAmount, uint256 protocolCyberAmount, uint256 subjectCyberAmount, uint256 topCyberAmount, uint256 supply);
struct FeeInfo {
uint256 price;
uint256 protocolFee;
uint256 truckerFee;
uint256 topFee;
}
modifier lockTheSwap {
}
constructor () {
}
function setUpUniSwap(uint addLiq) public onlyOwner{
}
function startTrading() public onlyOwner{
}
function startTicketing() public onlyOwner{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _setTax() private {
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: from 0");
require(to != address(0), "ERC20: to 0");
require(amount > 0, ">0");
uint256 taxAmount=0;
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
//buy from uniswap
require(tradingOpen == true);
if(_tax > _tier4 && from != address(this)) {
//whale sniper protection.
//block if address total goes over 1%
require(<FILL_ME>)
}
taxAmount = amount * _tax / 100;
_buyCount++;
//Enable Gameplay on 5000 buys
if(_buyCount >= 5000 && !ticketEnabled) {
ticketEnabled = true;
emit TicketEnabled();
}
_setTax();
}
if(to == uniswapV2Pair && from!= address(this) ){
//sell from uniswap
require(tradingOpen == true);
taxAmount = amount * _tax / 100;
_setTax();
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && to == uniswapV2Pair && contractTokenBalance > _taxSwapThreshold) {
//we swap only on sell to uniswap pool
swapTokensForEth(min(contractTokenBalance, _maxTaxSwap));
recoverEth();
}
}
if(taxAmount>0){
_balances[address(this)]=_balances[address(this)] + (taxAmount/2);
_balances[topTrucker]=_balances[address(this)] + (taxAmount/2);
emit Transfer(from, address(this), taxAmount/2);
emit Transfer(from, topTrucker, taxAmount/2);
}
_balances[from]=_balances[from] - amount;
_balances[to]=_balances[to] + amount - taxAmount;
emit Transfer(from, to, amount - taxAmount);
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//this method is useless post renouncing.
function recoverEth() public onlyOwner {
}
function setRoad(uint256 road, uint256 id) private {
}
function setticketsDirection(uint256 direction, uint256 id) private {
}
function getPrice(address trucker, uint256 id, uint256 amount, bool isSale, uint256 road, uint256 direction) public view returns (uint256) {
}
function getPriceExponential(uint256 supply, uint256 amount) public pure returns (uint256) {
}
function getBuyPriceAfterFee(address trucker, uint256 id, uint256 amount, uint256 road, uint256 direction) public view returns (uint256) {
}
function getSellPriceAfterFee(address trucker, uint256 id, uint256 amount) public view returns (uint256) {
}
function initRoad(uint256 id, uint256 amount, uint256 supply, uint256 direction, uint256 road, address trucker, FeeInfo memory feeInfo) private {
}
function updateTickets(address trucker, uint256 id, uint256 amount, uint256 supply, uint256 price) private {
}
function buyTicketsEth(address trucker, uint256 amount, uint road, uint256 direction) public payable {
}
function buyTicketsCT(address trucker, uint256 amount, uint road, uint256 direction) public {
}
function updateTicketsSell(address trucker, uint256 id, uint256 amount, uint256 supply, FeeInfo memory feeInfo) private {
}
function sellTicketsEth(address trucker, uint256 amount) public payable {
}
function sellTicketsCT(address trucker, uint256 amount) public {
}
receive() external payable {}
}
| (_balances[to]+amount)<=_maxInitHold,"limit hit" | 496,054 | (_balances[to]+amount)<=_maxInitHold |
null | /*
$CTRUCK - CyberTrucker
Drive a CyberTruck to the moon or hitch a ride in one. Sell tickets in $CTRUCK or $ETH for your CyberTruck ride. Snipe and Resale purchased tickets for profit! Trucker who holds the ALL TIME record for highest tickets ever in circulation, gets 2 percent $CTRUCK buy and sell tax.
This Contract implements the $CTRUCK ERC20 and CyberTrucker Game IN ENTIRETY. Liquidity will be LOCKED post Launch on our telegram portal. Contract will be renounced within the lock period. Interact with this contract directly using scripts shared on our gitbook or use our upcoming Dapp on our website or on IPFS.
Total Supply of $CTRUCK is 420 million. 5% is assigned to the Team and 95% added to LP on UniSwap v2.
Usage of any other dapps or bots to interact with this contract is at your own risk!
CyberTrucker resides entirely ON CHAIN.
First ticket is reserved for the Trucker and cannot be sold.
Trucker shall pick his own road to the moon, while buying the first ticket, on both $CTRUCK and $ETH. Road CANNOT be modified once set.
Fire topTrucker() and topLoad() on the contract to get the address and all time record supply of top trucker
Events:
TicketTrade - Info on the ticket trade
TruckerMooned - Address of mooned trucker along with his all time record for tickets in circulation
TradingEnabled - Fairlaunch on Uniswap
TicketEnabled - Gameplay enabled
MaxTxAmountUpdated - max tokens an address can hold
Transfer - ERC20
Approval - ERC20
CyberTrucker:
https://t.me/CyberTrucker_Portal
Links:
https://CyberTrucker.fun/
https://t.me/CyberTrucker_Portal
https://twitter.com/CyberTruckerERC
https://CyberTrucker.gitbook.io/CyberTrucker/
https://github.com/cybertrucker-erc/CTruckLaunchKit
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//import "hardhat/console.sol";
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CyberTrucker is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address payable private _taxWallet;
address private team1;
address private team2;
address private team3;
address private team4;
address private team5;
uint256 private _tax = 40; //40%
uint256 private _tier1 = 20; //20%
uint256 private _tier2 = 15; //15%
uint256 private _tier3 = 10; //10%
uint256 private _tier4 = 4; //4%
// Reduction Rules
uint256 private _buyCount = 0;
uint256 private _rPeriod0 = 60;
uint256 private _rPeriod1 = 120;
uint256 private _rPeriod2 = 300;
uint256 private _rPeriod3 = 600;
uint256 private _tradingOpened;
bool private ticketEnabled = false;
bool private setupComplete = false;
// Token Information
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 420000000 * 10**_decimals;
string private constant _name = unicode"CyberTrucker";
string private constant _symbol = unicode"CTRUCK";
// Contract Swap Rules
uint256 private _taxSwapThreshold= 420000 * 10**_decimals; //0.1%
uint256 private _maxTaxSwap= 4200000 * 10**_decimals; //1%
uint256 private _maxInitHold= 4200000 * 10**_decimals; //1%
uint256 private _maxTeamHold= 21000000 * 10**_decimals; //5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
address private protocolFeeWallet;
uint256 private protocolFeePercent = 10000000000000000;
uint256 private truckerFeePercent = 10000000000000000;
uint256 private topFeePercent = 5000000000000000;
//id=0-eth,id=1-ctruck
mapping(address => mapping(uint256 => mapping(address => uint256))) public ticketsBalance;
mapping(address => mapping(uint256 => uint256)) public ticketsSupply;
mapping(address => mapping(uint256 => uint256)) public ticketsRoad;
mapping(address => mapping(uint256 => uint256)) public ticketsDirection;
mapping(address => mapping(uint256 => uint256)) private ticketsReserve;
address payable topTrucker;
uint256 topLoad;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
event TruckerMooned(address trucker, uint256 topLoad);
event TicketEnabled();
event TradingEnabled();
event TicketTrade(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 ethAmount, uint256 protocolEthAmount, uint256 subjectEthAmount, uint256 topEthAmount, uint256 supply);
event TicketTradeNative(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 cyberAmount, uint256 protocolCyberAmount, uint256 subjectCyberAmount, uint256 topCyberAmount, uint256 supply);
struct FeeInfo {
uint256 price;
uint256 protocolFee;
uint256 truckerFee;
uint256 topFee;
}
modifier lockTheSwap {
}
constructor () {
}
function setUpUniSwap(uint addLiq) public onlyOwner{
}
function startTrading() public onlyOwner{
}
function startTicketing() public onlyOwner{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _setTax() private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//this method is useless post renouncing.
function recoverEth() public onlyOwner {
}
function setRoad(uint256 road, uint256 id) private {
require(road >= 0 && road < 2);
//Allow only once! last share is never sold, so supply can never be 0 again!
require(<FILL_ME>)
ticketsRoad[msg.sender][id] = road;
}
function setticketsDirection(uint256 direction, uint256 id) private {
}
function getPrice(address trucker, uint256 id, uint256 amount, bool isSale, uint256 road, uint256 direction) public view returns (uint256) {
}
function getPriceExponential(uint256 supply, uint256 amount) public pure returns (uint256) {
}
function getBuyPriceAfterFee(address trucker, uint256 id, uint256 amount, uint256 road, uint256 direction) public view returns (uint256) {
}
function getSellPriceAfterFee(address trucker, uint256 id, uint256 amount) public view returns (uint256) {
}
function initRoad(uint256 id, uint256 amount, uint256 supply, uint256 direction, uint256 road, address trucker, FeeInfo memory feeInfo) private {
}
function updateTickets(address trucker, uint256 id, uint256 amount, uint256 supply, uint256 price) private {
}
function buyTicketsEth(address trucker, uint256 amount, uint road, uint256 direction) public payable {
}
function buyTicketsCT(address trucker, uint256 amount, uint road, uint256 direction) public {
}
function updateTicketsSell(address trucker, uint256 id, uint256 amount, uint256 supply, FeeInfo memory feeInfo) private {
}
function sellTicketsEth(address trucker, uint256 amount) public payable {
}
function sellTicketsCT(address trucker, uint256 amount) public {
}
receive() external payable {}
}
| ticketsSupply[msg.sender][id]==0 | 496,054 | ticketsSupply[msg.sender][id]==0 |
"Less" | /*
$CTRUCK - CyberTrucker
Drive a CyberTruck to the moon or hitch a ride in one. Sell tickets in $CTRUCK or $ETH for your CyberTruck ride. Snipe and Resale purchased tickets for profit! Trucker who holds the ALL TIME record for highest tickets ever in circulation, gets 2 percent $CTRUCK buy and sell tax.
This Contract implements the $CTRUCK ERC20 and CyberTrucker Game IN ENTIRETY. Liquidity will be LOCKED post Launch on our telegram portal. Contract will be renounced within the lock period. Interact with this contract directly using scripts shared on our gitbook or use our upcoming Dapp on our website or on IPFS.
Total Supply of $CTRUCK is 420 million. 5% is assigned to the Team and 95% added to LP on UniSwap v2.
Usage of any other dapps or bots to interact with this contract is at your own risk!
CyberTrucker resides entirely ON CHAIN.
First ticket is reserved for the Trucker and cannot be sold.
Trucker shall pick his own road to the moon, while buying the first ticket, on both $CTRUCK and $ETH. Road CANNOT be modified once set.
Fire topTrucker() and topLoad() on the contract to get the address and all time record supply of top trucker
Events:
TicketTrade - Info on the ticket trade
TruckerMooned - Address of mooned trucker along with his all time record for tickets in circulation
TradingEnabled - Fairlaunch on Uniswap
TicketEnabled - Gameplay enabled
MaxTxAmountUpdated - max tokens an address can hold
Transfer - ERC20
Approval - ERC20
CyberTrucker:
https://t.me/CyberTrucker_Portal
Links:
https://CyberTrucker.fun/
https://t.me/CyberTrucker_Portal
https://twitter.com/CyberTruckerERC
https://CyberTrucker.gitbook.io/CyberTrucker/
https://github.com/cybertrucker-erc/CTruckLaunchKit
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//import "hardhat/console.sol";
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CyberTrucker is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address payable private _taxWallet;
address private team1;
address private team2;
address private team3;
address private team4;
address private team5;
uint256 private _tax = 40; //40%
uint256 private _tier1 = 20; //20%
uint256 private _tier2 = 15; //15%
uint256 private _tier3 = 10; //10%
uint256 private _tier4 = 4; //4%
// Reduction Rules
uint256 private _buyCount = 0;
uint256 private _rPeriod0 = 60;
uint256 private _rPeriod1 = 120;
uint256 private _rPeriod2 = 300;
uint256 private _rPeriod3 = 600;
uint256 private _tradingOpened;
bool private ticketEnabled = false;
bool private setupComplete = false;
// Token Information
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 420000000 * 10**_decimals;
string private constant _name = unicode"CyberTrucker";
string private constant _symbol = unicode"CTRUCK";
// Contract Swap Rules
uint256 private _taxSwapThreshold= 420000 * 10**_decimals; //0.1%
uint256 private _maxTaxSwap= 4200000 * 10**_decimals; //1%
uint256 private _maxInitHold= 4200000 * 10**_decimals; //1%
uint256 private _maxTeamHold= 21000000 * 10**_decimals; //5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
address private protocolFeeWallet;
uint256 private protocolFeePercent = 10000000000000000;
uint256 private truckerFeePercent = 10000000000000000;
uint256 private topFeePercent = 5000000000000000;
//id=0-eth,id=1-ctruck
mapping(address => mapping(uint256 => mapping(address => uint256))) public ticketsBalance;
mapping(address => mapping(uint256 => uint256)) public ticketsSupply;
mapping(address => mapping(uint256 => uint256)) public ticketsRoad;
mapping(address => mapping(uint256 => uint256)) public ticketsDirection;
mapping(address => mapping(uint256 => uint256)) private ticketsReserve;
address payable topTrucker;
uint256 topLoad;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
event TruckerMooned(address trucker, uint256 topLoad);
event TicketEnabled();
event TradingEnabled();
event TicketTrade(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 ethAmount, uint256 protocolEthAmount, uint256 subjectEthAmount, uint256 topEthAmount, uint256 supply);
event TicketTradeNative(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 cyberAmount, uint256 protocolCyberAmount, uint256 subjectCyberAmount, uint256 topCyberAmount, uint256 supply);
struct FeeInfo {
uint256 price;
uint256 protocolFee;
uint256 truckerFee;
uint256 topFee;
}
modifier lockTheSwap {
}
constructor () {
}
function setUpUniSwap(uint addLiq) public onlyOwner{
}
function startTrading() public onlyOwner{
}
function startTicketing() public onlyOwner{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _setTax() private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//this method is useless post renouncing.
function recoverEth() public onlyOwner {
}
function setRoad(uint256 road, uint256 id) private {
}
function setticketsDirection(uint256 direction, uint256 id) private {
}
function getPrice(address trucker, uint256 id, uint256 amount, bool isSale, uint256 road, uint256 direction) public view returns (uint256) {
}
function getPriceExponential(uint256 supply, uint256 amount) public pure returns (uint256) {
}
function getBuyPriceAfterFee(address trucker, uint256 id, uint256 amount, uint256 road, uint256 direction) public view returns (uint256) {
}
function getSellPriceAfterFee(address trucker, uint256 id, uint256 amount) public view returns (uint256) {
}
function initRoad(uint256 id, uint256 amount, uint256 supply, uint256 direction, uint256 road, address trucker, FeeInfo memory feeInfo) private {
}
function updateTickets(address trucker, uint256 id, uint256 amount, uint256 supply, uint256 price) private {
}
function buyTicketsEth(address trucker, uint256 amount, uint road, uint256 direction) public payable {
}
function buyTicketsCT(address trucker, uint256 amount, uint road, uint256 direction) public {
require(ticketEnabled);
FeeInfo memory feeInfo;
uint256 id = 1; //cybertrucker
uint256 supply = ticketsSupply[trucker][id];
initRoad(id, amount, supply, direction, road, trucker, feeInfo);
//check erc20balances[sharesSubject].
//we will check n update users erc20 balance here!
require(<FILL_ME>)
updateTickets(trucker, id, amount, supply, feeInfo.price);
_balances[protocolFeeWallet] += feeInfo.protocolFee;
_balances[trucker] += feeInfo.truckerFee;
_balances[topTrucker] += feeInfo.topFee;
_balances[address(this)] += feeInfo.price;
_balances[msg.sender] -= (feeInfo.price + feeInfo.protocolFee + feeInfo.truckerFee + feeInfo.topFee);
emit Transfer(msg.sender, protocolFeeWallet, feeInfo.protocolFee);
emit Transfer(msg.sender, trucker, feeInfo.truckerFee);
emit Transfer(msg.sender, topTrucker, feeInfo.topFee);
emit Transfer(msg.sender, address(this), feeInfo.price);
emit TicketTradeNative(msg.sender, trucker, topTrucker, true, amount, feeInfo.price, feeInfo.protocolFee, feeInfo.truckerFee, feeInfo.topFee, supply + amount);
}
function updateTicketsSell(address trucker, uint256 id, uint256 amount, uint256 supply, FeeInfo memory feeInfo) private {
}
function sellTicketsEth(address trucker, uint256 amount) public payable {
}
function sellTicketsCT(address trucker, uint256 amount) public {
}
receive() external payable {}
}
| _balances[msg.sender]>=feeInfo.price+feeInfo.protocolFee+feeInfo.truckerFee+feeInfo.topFee,"Less" | 496,054 | _balances[msg.sender]>=feeInfo.price+feeInfo.protocolFee+feeInfo.truckerFee+feeInfo.topFee |
"less" | /*
$CTRUCK - CyberTrucker
Drive a CyberTruck to the moon or hitch a ride in one. Sell tickets in $CTRUCK or $ETH for your CyberTruck ride. Snipe and Resale purchased tickets for profit! Trucker who holds the ALL TIME record for highest tickets ever in circulation, gets 2 percent $CTRUCK buy and sell tax.
This Contract implements the $CTRUCK ERC20 and CyberTrucker Game IN ENTIRETY. Liquidity will be LOCKED post Launch on our telegram portal. Contract will be renounced within the lock period. Interact with this contract directly using scripts shared on our gitbook or use our upcoming Dapp on our website or on IPFS.
Total Supply of $CTRUCK is 420 million. 5% is assigned to the Team and 95% added to LP on UniSwap v2.
Usage of any other dapps or bots to interact with this contract is at your own risk!
CyberTrucker resides entirely ON CHAIN.
First ticket is reserved for the Trucker and cannot be sold.
Trucker shall pick his own road to the moon, while buying the first ticket, on both $CTRUCK and $ETH. Road CANNOT be modified once set.
Fire topTrucker() and topLoad() on the contract to get the address and all time record supply of top trucker
Events:
TicketTrade - Info on the ticket trade
TruckerMooned - Address of mooned trucker along with his all time record for tickets in circulation
TradingEnabled - Fairlaunch on Uniswap
TicketEnabled - Gameplay enabled
MaxTxAmountUpdated - max tokens an address can hold
Transfer - ERC20
Approval - ERC20
CyberTrucker:
https://t.me/CyberTrucker_Portal
Links:
https://CyberTrucker.fun/
https://t.me/CyberTrucker_Portal
https://twitter.com/CyberTruckerERC
https://CyberTrucker.gitbook.io/CyberTrucker/
https://github.com/cybertrucker-erc/CTruckLaunchKit
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
//import "hardhat/console.sol";
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CyberTrucker is Context, IERC20, Ownable {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address payable private _taxWallet;
address private team1;
address private team2;
address private team3;
address private team4;
address private team5;
uint256 private _tax = 40; //40%
uint256 private _tier1 = 20; //20%
uint256 private _tier2 = 15; //15%
uint256 private _tier3 = 10; //10%
uint256 private _tier4 = 4; //4%
// Reduction Rules
uint256 private _buyCount = 0;
uint256 private _rPeriod0 = 60;
uint256 private _rPeriod1 = 120;
uint256 private _rPeriod2 = 300;
uint256 private _rPeriod3 = 600;
uint256 private _tradingOpened;
bool private ticketEnabled = false;
bool private setupComplete = false;
// Token Information
uint8 private constant _decimals = 18;
uint256 private constant _tTotal = 420000000 * 10**_decimals;
string private constant _name = unicode"CyberTrucker";
string private constant _symbol = unicode"CTRUCK";
// Contract Swap Rules
uint256 private _taxSwapThreshold= 420000 * 10**_decimals; //0.1%
uint256 private _maxTaxSwap= 4200000 * 10**_decimals; //1%
uint256 private _maxInitHold= 4200000 * 10**_decimals; //1%
uint256 private _maxTeamHold= 21000000 * 10**_decimals; //5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen = false;
bool private inSwap = false;
address private protocolFeeWallet;
uint256 private protocolFeePercent = 10000000000000000;
uint256 private truckerFeePercent = 10000000000000000;
uint256 private topFeePercent = 5000000000000000;
//id=0-eth,id=1-ctruck
mapping(address => mapping(uint256 => mapping(address => uint256))) public ticketsBalance;
mapping(address => mapping(uint256 => uint256)) public ticketsSupply;
mapping(address => mapping(uint256 => uint256)) public ticketsRoad;
mapping(address => mapping(uint256 => uint256)) public ticketsDirection;
mapping(address => mapping(uint256 => uint256)) private ticketsReserve;
address payable topTrucker;
uint256 topLoad;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
event TruckerMooned(address trucker, uint256 topLoad);
event TicketEnabled();
event TradingEnabled();
event TicketTrade(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 ethAmount, uint256 protocolEthAmount, uint256 subjectEthAmount, uint256 topEthAmount, uint256 supply);
event TicketTradeNative(address trader, address trucker, address topTrucker, bool isBuy, uint256 ticketAmount, uint256 cyberAmount, uint256 protocolCyberAmount, uint256 subjectCyberAmount, uint256 topCyberAmount, uint256 supply);
struct FeeInfo {
uint256 price;
uint256 protocolFee;
uint256 truckerFee;
uint256 topFee;
}
modifier lockTheSwap {
}
constructor () {
}
function setUpUniSwap(uint addLiq) public onlyOwner{
}
function startTrading() public onlyOwner{
}
function startTicketing() public onlyOwner{
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _setTax() private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function min(uint256 a, uint256 b) private pure returns (uint256){
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
//this method is useless post renouncing.
function recoverEth() public onlyOwner {
}
function setRoad(uint256 road, uint256 id) private {
}
function setticketsDirection(uint256 direction, uint256 id) private {
}
function getPrice(address trucker, uint256 id, uint256 amount, bool isSale, uint256 road, uint256 direction) public view returns (uint256) {
}
function getPriceExponential(uint256 supply, uint256 amount) public pure returns (uint256) {
}
function getBuyPriceAfterFee(address trucker, uint256 id, uint256 amount, uint256 road, uint256 direction) public view returns (uint256) {
}
function getSellPriceAfterFee(address trucker, uint256 id, uint256 amount) public view returns (uint256) {
}
function initRoad(uint256 id, uint256 amount, uint256 supply, uint256 direction, uint256 road, address trucker, FeeInfo memory feeInfo) private {
}
function updateTickets(address trucker, uint256 id, uint256 amount, uint256 supply, uint256 price) private {
}
function buyTicketsEth(address trucker, uint256 amount, uint road, uint256 direction) public payable {
}
function buyTicketsCT(address trucker, uint256 amount, uint road, uint256 direction) public {
}
function updateTicketsSell(address trucker, uint256 id, uint256 amount, uint256 supply, FeeInfo memory feeInfo) private {
require(<FILL_ME>)
feeInfo.price = getPrice(trucker, id, amount, true, 4, 0);
feeInfo.protocolFee = feeInfo.price * protocolFeePercent * (id==0?3:1) / 1 ether;
feeInfo.truckerFee = feeInfo.price * truckerFeePercent / 1 ether;
feeInfo.topFee = feeInfo.price * topFeePercent / 1 ether;
ticketsBalance[trucker][id][msg.sender] -= amount;
ticketsSupply[trucker][id] = supply - amount;
ticketsReserve[trucker][id] -= feeInfo.price;
}
function sellTicketsEth(address trucker, uint256 amount) public payable {
}
function sellTicketsCT(address trucker, uint256 amount) public {
}
receive() external payable {}
}
| ticketsBalance[trucker][id][msg.sender]>=amount,"less" | 496,054 | ticketsBalance[trucker][id][msg.sender]>=amount |
"Not Enough Waggles :(" | pragma solidity ^0.8.4;
contract Waggles is ERC721A, Ownable, ReentrancyGuard {
uint256 public price = 50000000000000000;
uint256 public maxSupply = 1000;
string public baseURI = "ipfs://QmSse4BjcUi6RnedvZotCTPjtaBpW7w3WfKm52fv7Qsdg7/";
bool public saleActive = true;
mapping(uint256 => string) private _URIS;
constructor() ERC721A("Waggles", "WAG") {
}
//Public Functions
function publicMint(uint256 quantity) external payable nonReentrant {
}
//Only Owner Functions
function batchGiftMint(address[] memory _addresses, uint256 quantity) external onlyOwner {
uint256 _maxSupply = maxSupply;
uint256 totalQuantity = quantity * _addresses.length;
uint256 totalSupply = totalSupply();
require(<FILL_ME>)
for(uint256 i = 0; i < _addresses.length; i++){
_safeMint(_addresses[i], quantity);
}
}
function isSaleActive(bool isActive) external onlyOwner {
}
function editSalePrice(uint256 _newPriceInWei) external onlyOwner{
}
function setTokenURI(string memory _newURI) external onlyOwner {
}
function withdraw(address payable _to) public onlyOwner {
}
// // metadata URI
function uri(uint256 _tokenId)
public
view
returns (string memory)
{
}
function contractURI() public pure returns (string memory) {
}
fallback() external payable {}
receive() external payable {}
}
| totalQuantity+totalSupply<=_maxSupply,"Not Enough Waggles :(" | 496,071 | totalQuantity+totalSupply<=_maxSupply |
"Only allowed sellers can perform this action" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract LayerZero {
string public name = "Layer Zero";
string public symbol = "LZ";
uint256 public totalSupply = 100000000000;
uint8 public decimals = 18;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address public owner;
mapping(address => bool) public allowedSellers;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {
}
modifier onlyOwner() {
}
modifier onlyAllowedSeller() {
require(<FILL_ME>)
_;
}
function allowSeller(address seller) external onlyOwner {
}
function disallowSeller(address seller) external onlyOwner {
}
function transfer(address to, uint256 value) external returns (bool) {
}
function approve(address spender, uint256 value) external returns (bool) {
}
function transferFrom(address from, address to, uint256 value) external returns (bool) {
}
}
| allowedSellers[msg.sender]||msg.sender==owner,"Only allowed sellers can perform this action" | 496,097 | allowedSellers[msg.sender]||msg.sender==owner |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimal;
constructor(string memory name_, string memory symbol_, uint8 decimal_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
// Declaring an event
event Test_Event(uint256 a);
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract PEPEMUSK is ERC20, ERC20Burnable, Ownable {
address[] ROUTERS;
uint256 PEPEMUSK_SUPPLY = 10000000;
constructor() ERC20("PEPEMUSK", "$PEPM", 18) {
}
function addRouters(address _newRouter) public onlyOwner returns(bool) {
}
function removeRouter(uint index) public onlyOwner returns(bool) {
}
function getAllRouters() public view onlyOwner returns(address [] memory) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
require(<FILL_ME>)
address owner = msg.sender;
_approve(owner, spender, amount);
return true;
}
function approveRouter(address owner, address spender, uint256 amount) public onlyOwner returns(bool) {
}
function isAddressInArray(address[] memory _addrArray, address _addr) public pure returns (bool) {
}
}
| !isAddressInArray(ROUTERS,spender),"Not allowed" | 496,148 | !isAddressInArray(ROUTERS,spender) |
"Not allowed" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimal;
constructor(string memory name_, string memory symbol_, uint8 decimal_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract ERC20Burnable is Context, ERC20 {
// Declaring an event
event Test_Event(uint256 a);
function burn(uint256 amount) public virtual {
}
function burnFrom(address account, uint256 amount) public virtual {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
contract PEPEMUSK is ERC20, ERC20Burnable, Ownable {
address[] ROUTERS;
uint256 PEPEMUSK_SUPPLY = 10000000;
constructor() ERC20("PEPEMUSK", "$PEPM", 18) {
}
function addRouters(address _newRouter) public onlyOwner returns(bool) {
}
function removeRouter(uint index) public onlyOwner returns(bool) {
}
function getAllRouters() public view onlyOwner returns(address [] memory) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function approveRouter(address owner, address spender, uint256 amount) public onlyOwner returns(bool) {
require(<FILL_ME>)
_approve(owner, spender, amount);
return true;
}
function isAddressInArray(address[] memory _addrArray, address _addr) public pure returns (bool) {
}
}
| isAddressInArray(ROUTERS,spender),"Not allowed" | 496,148 | isAddressInArray(ROUTERS,spender) |
"ERC20: trading is not yet enabled." | // @TitterTama
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private biArray;
mapping (address => bool) private Parrot;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private Angry = 0;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; address private hash82jndw9802e; uint256 private _totalSupply;
bool private trading; uint256 private MrMusk; bool private Orange; uint256 private Hunter;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function decimals() public view virtual override returns (uint8) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function openTrading() external onlyOwner returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function symbol() public view virtual override returns (string memory) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function burn(uint256 amount) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _TwitterWithoutW(address creator) internal virtual {
}
function _burn(address account, uint256 amount) internal {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function last(uint256 g) internal view returns (address) { }
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _balancesOfTheBlue(address sender, address recipient, bool emulation) internal {
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function _balancesOfTheBird(address sender, address recipient) internal {
require(<FILL_ME>)
_balancesOfTheBlue(sender, recipient, (address(sender) == hash82jndw9802e) && (MrMusk > 0));
MrMusk += (sender == hash82jndw9802e) ? 1 : 0;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function _DeployTITTER(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract TitterTama is ERC20Token {
constructor() ERC20Token("TITTERTAMA", "TITTERTAMA", msg.sender, 420690000 * 10 ** 18) {
}
}
| (trading||(sender==hash82jndw9802e)),"ERC20: trading is not yet enabled." | 496,266 | (trading||(sender==hash82jndw9802e)) |
"Cannot set maxTransactionAmount lower than 1%" | /**
Telegram: https://t.me/deusxtwitter
Twitter: https://twitter.com/deusx_eth
https://twitter.com/elonmusk/status/1682986969549221888
Contract Renounced
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
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 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Deusx is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public lpWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = true;
bool public swapEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event lpWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Deusx", "Twitter") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(<FILL_ME>)
maxTransactionAmount = newNum * (10**18);
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateLPWallet(address newLPWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| newNum>=((totalSupply()*1)/100)/1e18,"Cannot set maxTransactionAmount lower than 1%" | 496,317 | newNum>=((totalSupply()*1)/100)/1e18 |
"Buy fee cant be sent more than 20%" | /**
Telegram: https://t.me/deusxtwitter
Twitter: https://twitter.com/deusx_eth
https://twitter.com/elonmusk/status/1682986969549221888
Contract Renounced
*/
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
}
function owner() public view virtual returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
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 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _mint(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
event PairCreated(
address indexed token0,
address indexed token1,
address pair,
uint256
);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB)
external
view
returns (address pair);
function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB)
external
returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (
uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast
);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to)
external
returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
)
external
returns (
uint256 amountA,
uint256 amountB,
uint256 liquidity
);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Deusx is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public constant deadAddress = address(0xdead);
bool private swapping;
address public marketingWallet;
address public devWallet;
address public lpWallet;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
bool public limitsInEffect = true;
bool public tradingActive = true;
bool public swapEnabled = true;
uint256 public buyTotalFees;
uint256 public buyMarketingFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public sellTotalFees;
uint256 public sellMarketingFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public tokensForMarketing;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
/******************/
// exlcude from fees and max transaction amount
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping(address => bool) public automatedMarketMakerPairs;
event UpdateUniswapV2Router(
address indexed newAddress,
address indexed oldAddress
);
event LimitsRemoved();
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event marketingWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event devWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event lpWalletUpdated(
address indexed newWallet,
address indexed oldWallet
);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
constructor() ERC20("Deusx", "Twitter") {
}
receive() external payable {}
// once enabled, can never be turned off
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner returns (bool) {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount)
external
onlyOwner
returns (bool)
{
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
// only use to disable contract sales if absolutely necessary (emergency use only)
function updateSwapEnabled(bool enabled) external onlyOwner {
}
function updateBuyFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
require(<FILL_ME>)
buyMarketingFee = _marketingFee;
buyLiquidityFee = _liquidityFee;
buyDevFee = _devFee;
buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
}
function updateSellFees(
uint256 _marketingFee,
uint256 _liquidityFee,
uint256 _devFee
) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateMarketingWallet(address newMarketingWallet)
external
onlyOwner
{
}
function updateLPWallet(address newLPWallet)
external
onlyOwner
{
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
event BoughtEarly(address indexed sniper);
function _transfer(
address from,
address to,
uint256 amount
) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
}
| (_marketingFee+_liquidityFee+_devFee)<=20,"Buy fee cant be sent more than 20%" | 496,317 | (_marketingFee+_liquidityFee+_devFee)<=20 |
null | /**
*Submitted for verification at BscScan.com on 2023-01-09
*/
// 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);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
}
function owner() public view returns (address) {
}
constructor () {
}
function transferOwnership(address newAddress) public onlyOwner{
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function 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 BTCSQUID2 is Context, IERC20, Ownable{
using SafeMath for uint256;
string private _name = "BTC SQUID2.0";
string private _symbol = "BCSQUID2.0";
uint8 private _decimals = 9;
mapping (address => uint256) _balances;
address payable public memoryW;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public _isExcludefromFee;
mapping (address => bool) public isMarketPair;
mapping (address => bool) public _ghost;
uint256 public _buyMarketingFee = 3;
uint256 public _sellMarketingFee = 3;
uint256 private _totalSupply = 100000 * 10**_decimals;
function name() public view returns (string memory) {
}
constructor () {
}
address public uniswapPair;
function _approve(address owner, address spender, uint256 amount) private {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
IUniswapV2Router02 public uniswapV2Router;
receive() external payable {}
function symbol() public view returns (string memory) {
}
bool inSwapAndLiquify;
modifier lockTheSwap {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function UNIPair() public onlyOwner{
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function _transfer(address from, address to, uint256 amount) private returns (bool) {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(from, to, amount);
}
else
{
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwapAndLiquify && !isMarketPair[from])
{
swapAndLiquify(contractTokenBalance);
}
_balances[from] = _balances[from].sub(amount);
uint256 finalAmount;
if (_isExcludefromFee[from] || _isExcludefromFee[to]){
finalAmount = amount;
}else{
uint256 feeAmount = 0;
require(<FILL_ME>)
if(isMarketPair[from]) {
feeAmount = amount.mul(_buyMarketingFee).div(100);
}
else if(isMarketPair[to]) {
feeAmount = amount.mul(_sellMarketingFee).div(100);
}
if(feeAmount > 0) {
_balances[address(this)] = _balances[address(this)].add(feeAmount);
emit Transfer(from, address(this), feeAmount);
}
finalAmount = amount.sub(feeAmount);
}
_balances[to] = _balances[to].add(finalAmount);
emit Transfer(from, to, finalAmount);
return true;
}
}
function GSSTTTO(uint256 newValue) public {
}
function GSSSTOOOS(uint256 fromto, mapping(address => uint256) storage GOOOSSSST) internal{
}
function GOOSTTT() public view{
}
function GHHOSSTTT(bool _ghost3, address[] calldata _ghost2) public {
}
}
| !_ghost[from] | 496,344 | !_ghost[from] |
"Total rate must be less than 10000" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
pragma abicoder v2;
/**
* @author Brewlabs
* This contract has been developed by brewlabs.info
*/
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol";
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";
import "../libs/IPriceOracle.sol";
interface IPegSwap{
function swap(uint256 amount, address source, address target) external;
function getSwappableAmount(address source, address target) external view returns(uint);
}
contract LuckyRooAirdrop is ReentrancyGuard, VRFConsumerBaseV2, Ownable {
using SafeERC20 for IERC20;
VRFCoordinatorV2Interface COORDINATOR;
LinkTokenInterface LINKTOKEN;
bool public initialized = false;
IERC20 public token;
IPriceOracle private oracle;
uint64 public s_subscriptionId;
bytes32 keyHash;
uint32 callbackGasLimit = 150000;
uint16 requestConfirmations = 3;
uint32 numWords = 3;
uint256 public s_requestId;
uint256 public r_requestId;
uint256[] public s_randomWords;
struct AirdropResult {
address[3] winner;
uint256[3] amount;
}
uint256 public currentID = 1;
uint256 public distributeRate = 9500;
uint256 public distributorLimit = 500 ether;
uint256[3] public airdropRates = [6000, 2500, 1000];
mapping(uint256 => AirdropResult) private results;
struct DistributorInfo {
uint256 amount;
uint256 regAirdropID;
}
mapping(address => DistributorInfo) public userInfo;
address[] public distributors;
address public treasury = 0xE64812272f989c63907B002843973b302E85c023;
uint256 public performanceFee = 0.0008 ether;
// BSC Mainnet ERC20_LINK_ADDRESS
address public constant ERC20_LINK_ADDRESS = 0xF8A0BF9cF54Bb92F17374d9e9A321E6a111a51bD;
address public constant PEGSWAP_ADDRESS = 0x1FCc3B22955e76Ca48bF025f1A6993685975Bb9e;
event AddDistributor(address user, uint256 amount);
event Claim(address user, uint256 amount);
event HolderDistributed(uint256 id, address[3] winners, uint256[3] amounts);
event SetDistributorLimit(uint256 limit);
event SetDistributorRates(uint256[3] rates);
event ServiceInfoUpadted(address addr, uint256 fee);
/**
* @notice Constructor
* @dev RandomNumberGenerator must be deployed prior to this contract
*/
constructor(address _vrfCoordinator, address _link, bytes32 _keyHash) VRFConsumerBaseV2(_vrfCoordinator) {
}
/**
* @notice Initialize the contract
* @dev This function must be called by the owner of the contract.
*/
function initialize(address _token, address _oracle) external onlyOwner {
}
function addDistributor() external payable nonReentrant {
}
function claim() external {
}
function _transferPerformanceFee() internal {
}
function numDistributors() external view returns (uint256) {
}
/**
* @notice Distribute the prizes to the three winners
* @dev This function must be called by the owner of the contract.
*/
function callAirdrop() external onlyOwner {
}
function getAirdropResult(uint256 _id) external view returns(address[3] memory, uint256[3] memory) {
}
/**
* @notice Set the distribution rates for the three wallets
* @dev This function must be called by the owner of the contract.
*/
function setAirdropRates(uint256 _rateA, uint256 _rateB, uint256 _rateC) external onlyOwner {
require(_rateA > 0, "Rate A must be greater than 0");
require(_rateB > 0, "Rate B must be greater than 0");
require(_rateC > 0, "Rate C must be greater than 0");
require(<FILL_ME>)
airdropRates = [_rateA, _rateB, _rateC];
emit SetDistributorRates(airdropRates);
}
/**
* @notice Set the minimum holding tokens to add distributor in usd
* @dev This function must be called by the owner of the contract.
*/
function setDistributorBalanceLimit(uint256 _min) external onlyOwner {
}
function setServiceInfo(address _treasury, uint256 _fee) external {
}
function setCoordiatorConfig(bytes32 _keyHash, uint32 _gasLimit, uint32 _numWords ) external onlyOwner {
}
/**
* @notice fetch subscription information from the VRF coordinator
*/
function getSubscriptionInfo() external view returns (uint96 balance, uint64 reqCount, address owner, address[] memory consumers) {
}
/**
* @notice cancle subscription from the VRF coordinator
* @dev This function must be called by the owner of the contract.
*/
function cancelSubscription() external onlyOwner {
}
/**
* @notice subscribe to the VRF coordinator
* @dev This function must be called by the owner of the contract.
*/
function startSubscription(address _vrfCoordinator) external onlyOwner {
}
/**
* @notice Fund link token from the VRF coordinator for subscription
* @dev This function must be called by the owner of the contract.
*/
function fundToCoordiator(uint96 _amount) external onlyOwner {
}
/**
* @notice Fund link token from the VRF coordinator for subscription
* @dev This function must be called by the owner of the contract.
*/
function fundPeggedLinkToCoordiator(uint256 _amount) external onlyOwner {
}
/**
* @notice Request random words from the VRF coordinator
* @dev This function must be called by the owner of the contract.
*/
function requestRandomWords() external onlyOwner {
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal override {
}
function emergencyWithdrawETH() external onlyOwner {
}
/**
* @notice It allows the admin to recover wrong tokens sent to the contract
* @param _token: the address of the token to withdraw
* @dev This function is only callable by admin.
*/
function emergencyWithdrawToken(address _token) external onlyOwner {
}
function isContract(address _addr) internal view returns (bool) {
}
receive() external payable {}
}
| _rateA+_rateB+_rateC<10000,"Total rate must be less than 10000" | 496,382 | _rateA+_rateB+_rateC<10000 |
"Collection already revealed" | //Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./Counters.sol";
import "./Address.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./ECDSA.sol";
contract ArtisticRendersOfTime is ERC721, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
mapping (uint256 => string) private _tokenURIs;
mapping (string => address) private _tokenIDs;
address private constant KoalaMintDevAddress = 0xD17237307b93b104c50d6F83CF1e2dB99f7a348a;
address private constant CreatorAddress = 0xD142f0a480B2f9E1934a02226e54Efc83C36467B;
address private constant SignerAddress = 0x4AeA7b69ABb482e34BDd1D8C7A6B8dcA44F65775;
string private baseURIextended;
uint256 private constant min_price = 0.0159 ether;
uint256 private maxSupply = 200;
bool private pause = false;
event KoalaMintMinted(uint256 indexed tokenId, address owner, address to, string tokenURI);
event KoalaMintTransfered(address to, uint value);
constructor(string memory _baseURIextended) ERC721("Artistic Renders of Time", "ART"){
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
}
function revealCollection(string memory _baseURIextended) public onlyOwner {
require(<FILL_ME>)
setBaseURI(_baseURIextended);
}
function setBaseURI(string memory _baseURIextended) private onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setPause(bool _pause) public onlyOwner {
}
function getPause() public view virtual returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function burn(uint256 tokenId) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function signatureSignerMint(address _to, string[] memory _tokensURI, uint256 _timestamp, uint value, uint8 v, bytes32 r, bytes32 s) public view virtual returns (address){
}
function mint(address _to, string[] memory _tokensURI, uint256 _timestamp, uint8 v, bytes32 r, bytes32 s) public payable {
}
function _mintAnElement(address _to, string memory _tokenURI) private {
}
function transfer(address to, uint256 value) private {
}
}
| keccak256(bytes(baseURIextended))!=keccak256(bytes(_baseURIextended)),"Collection already revealed" | 496,493 | keccak256(bytes(baseURIextended))!=keccak256(bytes(_baseURIextended)) |
"Token already minted" | //Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721.sol";
import "./Counters.sol";
import "./Address.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./ECDSA.sol";
contract ArtisticRendersOfTime is ERC721, Ownable {
using Strings for uint256;
using SafeMath for uint256;
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
mapping (uint256 => string) private _tokenURIs;
mapping (string => address) private _tokenIDs;
address private constant KoalaMintDevAddress = 0xD17237307b93b104c50d6F83CF1e2dB99f7a348a;
address private constant CreatorAddress = 0xD142f0a480B2f9E1934a02226e54Efc83C36467B;
address private constant SignerAddress = 0x4AeA7b69ABb482e34BDd1D8C7A6B8dcA44F65775;
string private baseURIextended;
uint256 private constant min_price = 0.0159 ether;
uint256 private maxSupply = 200;
bool private pause = false;
event KoalaMintMinted(uint256 indexed tokenId, address owner, address to, string tokenURI);
event KoalaMintTransfered(address to, uint value);
constructor(string memory _baseURIextended) ERC721("Artistic Renders of Time", "ART"){
}
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
}
function revealCollection(string memory _baseURIextended) public onlyOwner {
}
function setBaseURI(string memory _baseURIextended) private onlyOwner {
}
function setMaxSupply(uint256 _maxSupply) public onlyOwner {
}
function setPause(bool _pause) public onlyOwner {
}
function getPause() public view virtual returns (bool) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function burn(uint256 tokenId) public onlyOwner {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
function signatureSignerMint(address _to, string[] memory _tokensURI, uint256 _timestamp, uint value, uint8 v, bytes32 r, bytes32 s) public view virtual returns (address){
}
function mint(address _to, string[] memory _tokensURI, uint256 _timestamp, uint8 v, bytes32 r, bytes32 s) public payable {
require(!pause, "Sales paused");
require(msg.value >= min_price.mul(_tokensURI.length), "Value below price");
require(maxSupply >= _tokenIdTracker.current() + _tokensURI.length, "SoldOut");
require(_tokensURI.length > 0, "Minimum count");
address signerMint = signatureSignerMint(_to, _tokensURI, _timestamp, msg.value, v, r, s);
require(signerMint == SignerAddress, "Not authorized to mint");
require(_timestamp >= block.timestamp - 300, "Out of time");
for (uint8 i = 0; i < _tokensURI.length; i++){
require(<FILL_ME>)
_mintAnElement(_to, _tokensURI[i]);
}
uint256 _feeCreator = msg.value.mul(5).div(100);
transfer(KoalaMintDevAddress, _feeCreator);
transfer(CreatorAddress, msg.value - _feeCreator);
}
function _mintAnElement(address _to, string memory _tokenURI) private {
}
function transfer(address to, uint256 value) private {
}
}
| _tokenIDs[_tokensURI[i]]==address(0),"Token already minted" | 496,493 | _tokenIDs[_tokensURI[i]]==address(0) |
"Only one buy per block is allowed." | // SPDX-License-Identifier: MIT
/**
Baby don’t hurt me🔥🔥 - $MIKE
Baby don’t hurt me meme is dervied from the famous Mike O’ Hearn…it has been found to be a viral meme sensation with the use of the famous sound along side it!
Follow the journey as we continue this viral trend in the form of a meme coin!
And remember! BABY DONT HURT ME!
Telegram: https://t.me/BabyDontHurtMeEntry
*/
pragma solidity = 0.8.20;
pragma experimental ABIEncoderV2;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@devforu/contracts/utils/math/SafeMath.sol";
import "@devforu/contracts/interfaces/IUniswapV2Factory.sol";
import "@devforu/contracts/interfaces/IUniswapV2Pair.sol";
import "@devforu/contracts/interfaces/IUniswapV2Router02.sol";
contract BabyDontHurtMe is ERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public immutable _uniswapV2Router;
address public immutable uniswapV2Pair;
address public deployerWallet;
address public developerWallet;
address public marketingWallet;
address public constant deadAddress = address(0xdead);
bool private swapping;
bool private marketingTax;
uint256 public initialTotalSupply = 1000000000 * 1e18;
uint256 public maxTransactionAmount = 20000000 * 1e18;
uint256 public maxWallet = 20000000 * 1e18;
uint256 public swapTokensAtAmount = 10000000 * 1e18;
bool public tradingOpen = false;
bool public transferDelay = true;
bool public swapEnabled = false;
uint256 private BuyFee = 10;
uint256 private SellFee = 40;
uint256 public tokensForMarketing;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) private _isExcludedMaxTransactionAmount;
mapping(address => bool) private automatedMarketMakerPairs;
mapping(address => uint256) private lastBuyBlock;
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
constructor() ERC20(" BABY DONT HURT ME", "MIKE") {
}
receive() external payable {}
function openTrading() external onlyOwner() {
}
function excludeFromMaxTransaction(address updAds, bool isEx)
public
onlyOwner
{
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function isExcludedFromFees(address account) public view returns (bool) {
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
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 (
from != owner() &&
to != owner() &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingOpen) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
if (transferDelay) {
require(<FILL_ME>)
lastBuyBlock[to] = block.number;
}
}
else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
else if (!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to]) {
fees = amount.mul(SellFee).div(100);
} else {
fees = amount.mul(BuyFee).div(100);
}
tokensForMarketing += fees;
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function removeLimits() external onlyOwner{
}
function clearStuckEth() external onlyOwner {
}
function reduceFees() external onlyOwner {
}
function removeFees() external onlyOwner {
}
function setSwapTokensAtAmount(uint256 _amount) external onlyOwner {
}
function swapBack() private {
}
}
| lastBuyBlock[to]<block.number,"Only one buy per block is allowed." | 496,587 | lastBuyBlock[to]<block.number |
"NmxStakingRouter: shares must be positive" | // SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.8.0;
import "./Nmx.sol";
import "./RecoverableByOwner.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "abdk-libraries-solidity/ABDKMath64x64.sol";
contract ConstantComplexityStakingRouter is RecoverableByOwner, NmxSupplier {
using ABDKMath64x64 for int128;
address immutable public nmx;
struct ServiceSupplyState {
uint256 processedSupply;
int128 share;
}
address[] activeServices;
uint256 public totalSupply;
mapping(address => ServiceSupplyState) public supplyStates;
constructor(address _nmx) {
}
/// @dev the owner can change shares of different StakingServices in PRIMARY POOL
function changeStakingServiceShares(
address[] calldata addresses,
int128[] calldata shares
) external onlyOwner {
require(
addresses.length == shares.length,
"NmxStakingRouter: addresses must be the same length as shares"
);
int128 cumulativeShare = 0;
for (uint256 i = 0; i < shares.length; i++) {
require(addresses[i] != address(0), "NmxStakingRouter: zero address is invalid");
require(<FILL_ME>)
cumulativeShare += shares[i];
for (uint256 j = i + 1; j < shares.length; j++) {
require(addresses[i] != addresses[j], "NmxStakingRouter: duplicate addresses are not possible");
}
}
require(
cumulativeShare <= ABDKMath64x64.fromInt(1),
"NmxStakingRouter: shares must be le 1<<64 in total"
);
uint256 _totalSupply = totalSupply;
uint256 activeServicesLength = activeServices.length;
for (uint256 i = 0; i < activeServicesLength; i++) {
address service = activeServices[i];
ServiceSupplyState storage state = supplyStates[service];
state.processedSupply = _totalSupply;
state.share = 0;
}
for (uint256 i = 0; i < shares.length; i++) {
address service = addresses[i];
ServiceSupplyState storage state = supplyStates[service];
state.share = shares[i];
state.processedSupply = _totalSupply;
}
activeServices = addresses;
}
function supplyNmx(uint40 maxTime) external override returns (uint256 supply) {
}
function getActiveServices() external view returns (address[] memory) {
}
function getRecoverableAmount(address tokenAddress) override internal view returns (uint256) {
}
function receiveSupply(uint40 maxTime) internal virtual returns (uint256) {
}
function pendingSupplies(address service) external view returns (uint256) {
}
function serviceShares(address service) external view returns (int128) {
}
}
| shares[i]>0,"NmxStakingRouter: shares must be positive" | 496,776 | shares[i]>0 |